#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/TCPConsole.hpp>

Collaboration diagram for Slic3r::Utils::TCPConsole:

Public Member Functions
	TCPConsole ()
	TCPConsole (const std::string &host_name, const std::string &port_name)
	~TCPConsole ()=default
void	set_defaults ()
void	set_write_timeout (std::chrono::steady_clock::duration timeout)
void	set_read_timeout (std::chrono::steady_clock::duration timeout)
void	set_tcp_queue_delay (std::chrono::steady_clock::duration delay)
void	set_line_delimiter (const std::string &newline)
void	set_command_done_string (const std::string &done_string)
void	set_remote (const std::string &host_name, const std::string &port_name)
bool	enqueue_cmd (const SerialMessage &cmd)
bool	run_queue ()
std::string	error_message () const

Private Types
using	tcp = boost::asio::ip::tcp

Private Member Functions
void	handle_connect (const boost::system::error_code &ec)
void	handle_read (const boost::system::error_code &ec, std::size_t bytes_transferred)
void	handle_write (const boost::system::error_code &ec, std::size_t bytes_transferred, SerialMessageType messageType)
void	transmit_next_command ()
void	wait_next_line ()
std::string	extract_next_line ()
void	set_deadline_in (std::chrono::steady_clock::duration)
bool	is_deadline_over () const

Private Attributes
std::string	m_host_name
std::string	m_port_name
std::string	m_newline
std::string	m_done_string
std::chrono::steady_clock::duration	m_connect_timeout
std::chrono::steady_clock::duration	m_write_timeout
std::chrono::steady_clock::duration	m_read_timeout
std::chrono::steady_clock::duration	m_tcp_queue_delay
std::deque< SerialMessage >	m_cmd_queue
boost::asio::io_context	m_io_context
tcp::resolver	m_resolver
tcp::socket	m_socket
boost::asio::streambuf	m_recv_buffer
std::string	m_send_buffer
bool	m_is_connected
boost::system::error_code	m_error_code
std::chrono::steady_clock::time_point	m_deadline

Detailed Description

Member Typedef Documentation

◆ tcp

using Slic3r::Utils::TCPConsole::tcp = boost::asio::ip::tcp

private

Constructor & Destructor Documentation

◆ TCPConsole() [1/2]

Slic3r::Utils::TCPConsole::TCPConsole ( )

inline

26: m_resolver(m_io_context), m_socket(m_io_context) { set_defaults(); }

Slic3r::Utils::TCPConsole::m_resolver

tcp::resolver m_resolver

Definition TCPConsole.hpp:99

Slic3r::Utils::TCPConsole::set_defaults

void set_defaults()

Definition TCPConsole.hpp:31

Slic3r::Utils::TCPConsole::m_socket

tcp::socket m_socket

Definition TCPConsole.hpp:100

Slic3r::Utils::TCPConsole::m_io_context

boost::asio::io_context m_io_context

Definition TCPConsole.hpp:98

References m_io_context, m_resolver, m_socket, and set_defaults().

Here is the call graph for this function:

◆ TCPConsole() [2/2]

Slic3r::Utils::TCPConsole::TCPConsole	(	const std::string &	host_name,
		const std::string &	port_name )

inline

27 : m_resolver(m_io_context), m_socket(m_io_context)

28 { set_defaults(); set_remote(host_name, port_name); }

Slic3r::Utils::TCPConsole::set_remote

void set_remote(const std::string &host_name, const std::string &port_name)

Definition TCPConsole.hpp:60

References m_io_context, m_resolver, m_socket, set_defaults(), and set_remote().

Here is the call graph for this function:

◆ ~TCPConsole()

Slic3r::Utils::TCPConsole::~TCPConsole ( )

default

Member Function Documentation

◆ enqueue_cmd()

bool Slic3r::Utils::TCPConsole::enqueue_cmd ( const SerialMessage & cmd )

inline

                                               {
        // TODO: Add multithread protection to queue
        m_cmd_queue.push_back(cmd);
        return true;
    }

References m_cmd_queue.

Referenced by Slic3r::MKS::start_print(), and Slic3r::MKS::test().

Here is the caller graph for this function:

◆ error_message()

std::string Slic3r::Utils::TCPConsole::error_message ( ) const

inline

73{ return m_error_code.message(); }

Slic3r::Utils::TCPConsole::m_error_code

boost::system::error_code m_error_code

Definition TCPConsole.hpp:105

References m_error_code.

Referenced by Slic3r::MKS::start_print(), and Slic3r::MKS::test().

Here is the caller graph for this function:

◆ extract_next_line()

std::string Slic3r::Utils::TCPConsole::extract_next_line ( )

private

{
    char linebuf[1024];
    std::istream is(&m_recv_buffer);
    is.getline(linebuf, sizeof(linebuf));
    return is.good() ? linebuf : std::string{};
}

References m_recv_buffer.

Referenced by handle_read().

Here is the caller graph for this function:

◆ handle_connect()

void Slic3r::Utils::TCPConsole::handle_connect ( const boost::system::error_code & ec )

private

{
    m_error_code = ec;
 
    if (ec) {
        BOOST_LOG_TRIVIAL(error) << boost::format("TCPConsole: Can't connect to %1%:%2%: %3%")
            % m_host_name
            % m_port_name
            % ec.message();
 
        m_io_context.stop();
    }
    else {
        m_is_connected = true;
        BOOST_LOG_TRIVIAL(info) << boost::format("TCPConsole: connected to %1%:%2%")
            % m_host_name
            % m_port_name;
 
        transmit_next_command();
    }
}

References m_error_code, m_host_name, m_io_context, m_is_connected, m_port_name, and transmit_next_command().

Referenced by run_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_read()

void Slic3r::Utils::TCPConsole::handle_read	(	const boost::system::error_code &	ec,
		std::size_t	bytes_transferred )

private

{
    m_error_code = ec;
 
    if (ec) {
        BOOST_LOG_TRIVIAL(error) << boost::format("TCPConsole: Can't read from %1%:%2%: %3%")
            % m_host_name
            % m_port_name
            % ec.message();
 
        m_io_context.stop();
    }
    else {
        std::string line = extract_next_line();
        boost::trim(line);
 
        BOOST_LOG_TRIVIAL(debug) << boost::format("TCPConsole: received '%3%' from %1%:%2%")
            % m_host_name
            % m_port_name
            % line;
 
        boost::to_lower(line);
 
        if (line == m_done_string)
            transmit_next_command();
        else
            wait_next_line();
    }
}

References extract_next_line(), m_done_string, m_error_code, m_host_name, m_io_context, m_port_name, transmit_next_command(), and wait_next_line().

Referenced by wait_next_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_write()

void Slic3r::Utils::TCPConsole::handle_write	(	const boost::system::error_code &	ec,
		std::size_t	bytes_transferred,
		SerialMessageType	messageType )

private

{
    m_error_code = ec;
    if (ec) {
        BOOST_LOG_TRIVIAL(error) << boost::format("TCPConsole: Can't write to %1%:%2%: %3%")
            % m_host_name
            % m_port_name
            % ec.message();
 
        m_io_context.stop();
    }
    else {
        if(messageType == Command) {
            wait_next_line();
        }
        else {
            transmit_next_command();
        }
    }
}

References Slic3r::Utils::Command, m_error_code, m_host_name, m_io_context, m_port_name, transmit_next_command(), and wait_next_line().

Referenced by transmit_next_command().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_deadline_over()

bool Slic3r::Utils::TCPConsole::is_deadline_over ( ) const

private

{
    return m_deadline < std::chrono::steady_clock::now();
}

References m_deadline.

Referenced by run_queue().

Here is the caller graph for this function:

◆ run_queue()

bool Slic3r::Utils::TCPConsole::run_queue ( )

{
    try {
        // TODO: Add more resets and initializations after previous run (reset() method?..)
        set_deadline_in(m_connect_timeout);
        m_is_connected = false;
        m_io_context.restart();
 
        auto endpoints = m_resolver.resolve(m_host_name, m_port_name);
 
        m_socket.async_connect(endpoints->endpoint(),
            boost::bind(&TCPConsole::handle_connect, this, boost::placeholders::_1)
        );
 
        // Loop until we get any reasonable result. Negative result is also result.
        // TODO: Rewrite to more graceful way using deadlime_timer
        bool timeout = false;
        while (!(timeout = is_deadline_over()) && !m_io_context.stopped()) {
            if (m_error_code) {
                m_io_context.stop();
            }
            m_io_context.run_for(boost::asio::chrono::milliseconds(100));
        }
 
        // Override error message if timeout is set
        if (timeout)
            m_error_code = make_error_code(boost::asio::error::timed_out);
 
        // Socket is not closed automatically by boost
        m_socket.close();
 
        if (m_error_code) {
            // We expect that message is logged in handler
            return false;
        }
 
        // It's expected to have empty queue after successful exchange
        if (!m_cmd_queue.empty()) {
            BOOST_LOG_TRIVIAL(error) << "TCPConsole: command queue is not empty after end of exchange";
            return false;
        }
    }
    catch (std::exception& e)
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("TCPConsole: Exception while talking with %1%:%2%: %3%")
            % m_host_name
            % m_port_name
            % e.what();
 
        return false;
    }
 
    return true;
}

References handle_connect(), is_deadline_over(), m_cmd_queue, m_connect_timeout, m_error_code, m_host_name, m_io_context, m_is_connected, m_port_name, m_resolver, m_socket, and set_deadline_in().

Referenced by Slic3r::MKS::start_print(), and Slic3r::MKS::test().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_command_done_string()

void Slic3r::Utils::TCPConsole::set_command_done_string ( const std::string & done_string )

inline

                                                               {
        m_done_string = done_string;
    }

References m_done_string.

◆ set_deadline_in()

void Slic3r::Utils::TCPConsole::set_deadline_in ( std::chrono::steady_clock::duration d )

private

{
    m_deadline = std::chrono::steady_clock::now() + d;
}

References m_deadline.

Referenced by run_queue(), transmit_next_command(), and wait_next_line().

Here is the caller graph for this function:

◆ set_defaults()

void Slic3r::Utils::TCPConsole::set_defaults ( )

inline

    {
        m_newline = "\n";
        m_done_string = "ok";
        m_connect_timeout = std::chrono::milliseconds(5000);
        m_write_timeout = std::chrono::milliseconds(10000);
        m_read_timeout = std::chrono::milliseconds(10000);
        m_tcp_queue_delay = std::chrono::milliseconds(0);
    }

References m_connect_timeout, m_done_string, m_newline, m_read_timeout, m_tcp_queue_delay, and m_write_timeout.

Referenced by TCPConsole(), and TCPConsole().

Here is the caller graph for this function:

◆ set_line_delimiter()

void Slic3r::Utils::TCPConsole::set_line_delimiter ( const std::string & newline )

inline

                                                      {
        m_newline = newline;
    }

References m_newline.

◆ set_read_timeout()

void Slic3r::Utils::TCPConsole::set_read_timeout ( std::chrono::steady_clock::duration timeout )

inline

                                                                 {
        m_read_timeout = timeout;
    }

References m_read_timeout.

◆ set_remote()

void Slic3r::Utils::TCPConsole::set_remote	(	const std::string &	host_name,
		const std::string &	port_name )

inline

    {
        m_host_name = host_name;
        m_port_name = port_name;
    }

References m_host_name, and m_port_name.

Referenced by TCPConsole().

Here is the caller graph for this function:

◆ set_tcp_queue_delay()

void Slic3r::Utils::TCPConsole::set_tcp_queue_delay ( std::chrono::steady_clock::duration delay )

inline

                                                                  { 
        m_tcp_queue_delay = delay;
    }

References m_tcp_queue_delay.

◆ set_write_timeout()

void Slic3r::Utils::TCPConsole::set_write_timeout ( std::chrono::steady_clock::duration timeout )

inline

                                                                  {
        m_write_timeout = timeout;
    }

References m_write_timeout.

◆ transmit_next_command()

void Slic3r::Utils::TCPConsole::transmit_next_command ( )

private

{
    if (m_cmd_queue.empty()) {
        m_io_context.stop();
        return;
    }
 
    std::this_thread::sleep_for(m_tcp_queue_delay);
 
    SerialMessage cmd = m_cmd_queue.front();
    m_cmd_queue.pop_front();
 
    BOOST_LOG_TRIVIAL(debug) << boost::format("TCPConsole: transmitting '%3%' to %1%:%2%")
        % m_host_name
        % m_port_name
        % cmd.message;
 
    m_send_buffer = cmd.message;
 
    if (cmd.messageType == Command) {
        m_send_buffer += m_newline;
    }
 
    set_deadline_in(m_write_timeout);
    boost::asio::async_write(
        m_socket,
        boost::asio::buffer(m_send_buffer),
        boost::bind(&TCPConsole::handle_write, this, boost::placeholders::_1, boost::placeholders::_2, cmd.messageType)
    );
}

References Slic3r::Utils::Command, handle_write(), m_cmd_queue, m_host_name, m_io_context, m_newline, m_port_name, m_send_buffer, m_socket, m_tcp_queue_delay, m_write_timeout, Slic3r::Utils::SerialMessage::message, Slic3r::Utils::SerialMessage::messageType, and set_deadline_in().

Referenced by handle_connect(), handle_read(), and handle_write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wait_next_line()

void Slic3r::Utils::TCPConsole::wait_next_line ( )

private

{
    set_deadline_in(m_read_timeout);
    boost::asio::async_read_until(
        m_socket,
        m_recv_buffer,
        m_newline,
        boost::bind(&TCPConsole::handle_read, this, boost::placeholders::_1, boost::placeholders::_2)
    );
}