Slic3r::GUI::ProcessRunner Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ProcessRunner.hpp>

Inheritance diagram for Slic3r::GUI::ProcessRunner:

Collaboration diagram for Slic3r::GUI::ProcessRunner:

Classes
struct	OutputLine
struct	SyncResult

Public Types
using	OutputCallback = std::function<void(const std::vector<OutputLine>& lines)>
using	DoneCallback = std::function<void(int exit_code)>

Public Member Functions
	ProcessRunner ()
	~ProcessRunner () override
bool	run_command_line_async (const std::string &command_line, OutputCallback on_output, DoneCallback on_done)
void	write_stdin (const std::string &data)
bool	is_running () const
void	terminate ()

Static Public Member Functions
static SyncResult	run_sync (const std::string &executable, const std::vector< std::string > &args)

Private Member Functions
void	on_timer (wxTimerEvent &event)
void	finish_process (int exit_code)
void	start_reader_threads ()
void	join_reader_threads ()
void	enqueue_output (std::string line, bool is_stderr)
std::vector< OutputLine >	drain_output_queue ()
void	join_launch_thread ()

Private Attributes
wxTimer	m_poll_timer
std::atomic_bool	m_launching {false}
std::atomic_bool	m_launch_failed {false}
std::thread	m_launch_thread
std::thread	m_stdout_thread
std::thread	m_stderr_thread
std::mutex	m_output_mutex
std::vector< OutputLine >	m_output_queue
std::unique_ptr< boost::process::child >	m_process
std::unique_ptr< boost::process::ipstream >	m_stdout_pipe
std::unique_ptr< boost::process::ipstream >	m_stderr_pipe
std::unique_ptr< boost::process::opstream >	m_stdin_pipe
OutputCallback	m_on_output
DoneCallback	m_on_done

Detailed Description

---

Class Documentation

Slic3r::GUI::ProcessRunner::OutputLine

struct Slic3r::GUI::ProcessRunner::OutputLine

Collaboration diagram for Slic3r::GUI::ProcessRunner::OutputLine:

Class Members
bool	is_stderr
string	text

Slic3r::GUI::ProcessRunner::SyncResult

struct Slic3r::GUI::ProcessRunner::SyncResult

Collaboration diagram for Slic3r::GUI::ProcessRunner::SyncResult:

Class Members
int	exit_code = -1
string	stderr_output
string	stdout_output

Member Typedef Documentation

DoneCallback

using Slic3r::GUI::ProcessRunner::DoneCallback = std::function<void(int exit_code)>

OutputCallback

using Slic3r::GUI::ProcessRunner::OutputCallback = std::function<void(const std::vector<OutputLine>& lines)>

Constructor & Destructor Documentation

ProcessRunner()

Slic3r::GUI::ProcessRunner::ProcessRunner

(

)

    : m_poll_timer(this, wxID_ANY)
{
    Bind(wxEVT_TIMER, &ProcessRunner::on_timer, this);
}

References m_poll_timer, and on_timer().

Here is the call graph for this function:

~ProcessRunner()

Slic3r::GUI::ProcessRunner::~ProcessRunner ( )

override

{
    terminate();
}

References terminate().

Here is the call graph for this function:

Member Function Documentation

drain_output_queue()

std::vector< ProcessRunner::OutputLine > Slic3r::GUI::ProcessRunner::drain_output_queue ( )

private

{
    std::lock_guard<std::mutex> lock(m_output_mutex);
    std::vector<OutputLine> batch;
    batch.swap(m_output_queue);
    return batch;
}

References m_output_mutex, and m_output_queue.

Referenced by finish_process(), on_timer(), and run_command_line_async().

Here is the caller graph for this function:

enqueue_output()

void Slic3r::GUI::ProcessRunner::enqueue_output ( std::string line, bool is_stderr )

private

{
    std::lock_guard<std::mutex> lock(m_output_mutex);
    m_output_queue.push_back({std::move(line), is_stderr});
}

References m_output_mutex, and m_output_queue.

Referenced by start_reader_threads().

Here is the caller graph for this function:

finish_process()

void Slic3r::GUI::ProcessRunner::finish_process ( int exit_code )

private

{
    join_launch_thread();
    join_reader_threads();
 
    std::vector<OutputLine> final_batch = drain_output_queue();
    if (!final_batch.empty() && m_on_output)
        m_on_output(final_batch);
 
    m_process.reset();
    m_stdout_pipe.reset();
    m_stderr_pipe.reset();
    m_stdin_pipe.reset();
 
    if (m_on_done) {
        auto cb = std::move(m_on_done);
        m_on_done = nullptr;
        cb(exit_code);
    }
}

References drain_output_queue(), join_launch_thread(), join_reader_threads(), m_on_done, m_on_output, m_process, m_stderr_pipe, m_stdin_pipe, and m_stdout_pipe.

Referenced by on_timer(), and terminate().

Here is the call graph for this function:

Here is the caller graph for this function:

is_running()

bool Slic3r::GUI::ProcessRunner::is_running

(

)

const

{
    return m_launching.load() || (m_process && m_process->running());
}

References m_launching, and m_process.

Referenced by run_command_line_async().

Here is the caller graph for this function:

join_launch_thread()

void Slic3r::GUI::ProcessRunner::join_launch_thread ( )

private

{
    if (m_launch_thread.joinable())
        m_launch_thread.join();
}

References m_launch_thread.

Referenced by finish_process(), on_timer(), run_command_line_async(), and terminate().

Here is the caller graph for this function:

join_reader_threads()

void Slic3r::GUI::ProcessRunner::join_reader_threads ( )

private

{
    if (m_stdout_thread.joinable())
        m_stdout_thread.join();
    if (m_stderr_thread.joinable())
        m_stderr_thread.join();
}

References m_stderr_thread, and m_stdout_thread.

Referenced by finish_process(), and start_reader_threads().

Here is the caller graph for this function:

on_timer()

void Slic3r::GUI::ProcessRunner::on_timer ( wxTimerEvent & event )

private

{
    if (m_launching.load())
        return;
 
    join_launch_thread();
 
    if (m_launch_failed.exchange(false)) {
        m_poll_timer.Stop();
        finish_process(-1);
        return;
    }
 
    if (!m_process) {
        m_poll_timer.Stop();
        return;
    }
 
    std::vector<OutputLine> batch = drain_output_queue();
    if (!batch.empty() && m_on_output)
        m_on_output(batch);
 
    // Check if process exited
    if (!m_process->running()) {
        m_poll_timer.Stop();
        m_process->wait();
        const int exit_code = m_process->exit_code();
        finish_process(exit_code);
    }
}

References drain_output_queue(), finish_process(), join_launch_thread(), m_launch_failed, m_launching, m_on_output, m_poll_timer, and m_process.

Referenced by ProcessRunner().

Here is the call graph for this function:

Here is the caller graph for this function:

run_command_line_async()

bool Slic3r::GUI::ProcessRunner::run_command_line_async	(	const std::string &	command_line,
		OutputCallback	on_output,
		DoneCallback	on_done )

{
    if (!m_launching.load())
        join_launch_thread();
 
    if (is_running())
        return false;
 
    m_on_output = std::move(on_output);
    m_on_done   = std::move(on_done);
    drain_output_queue();
    m_launch_failed.store(false);
    m_launching.store(true);
 
    m_launch_thread = std::thread([this, command_line]() {
        namespace bp = boost::process;
 
        try {
            auto stdout_pipe = std::make_unique<bp::ipstream>();
            auto stderr_pipe = std::make_unique<bp::ipstream>();
            auto stdin_pipe  = std::make_unique<bp::opstream>();
 
            auto process = std::make_unique<bp::child>(
                bp::cmd = command_line,
                bp::env["PYTHONUNBUFFERED"] = "1",
                bp::env["PYTHONIOENCODING"] = "utf-8",
                bp::env["PYTHONUTF8"] = "1",
#ifdef _WIN32
                bp::windows::create_no_window,
#endif
                bp::std_in < *stdin_pipe,
                bp::std_out > *stdout_pipe,
                bp::std_err > *stderr_pipe);
 
            m_stdout_pipe = std::move(stdout_pipe);
            m_stderr_pipe = std::move(stderr_pipe);
            m_stdin_pipe  = std::move(stdin_pipe);
            m_process     = std::move(process);
            start_reader_threads();
        } catch (const std::exception&) {
            m_stdout_pipe.reset();
            m_stderr_pipe.reset();
            m_stdin_pipe.reset();
            m_process.reset();
            m_launch_failed.store(true);
        }
 
        m_launching.store(false);
    });
 
    m_poll_timer.Start(50);
    return true;
}

References drain_output_queue(), is_running(), join_launch_thread(), m_launch_failed, m_launch_thread, m_launching, m_on_done, m_on_output, m_poll_timer, m_process, m_stderr_pipe, m_stdin_pipe, m_stdout_pipe, and start_reader_threads().

Here is the call graph for this function:

run_sync()

ProcessRunner::SyncResult Slic3r::GUI::ProcessRunner::run_sync ( const std::string & executable, const std::vector< std::string > & args )

static

{
    SyncResult result;
 
    try {
        namespace bp = boost::process;
 
        bp::ipstream std_out;
        bp::ipstream std_err;
 
        bp::child child(executable, bp::args(args),
                        bp::std_out > std_out,
                        bp::std_err > std_err);
 
        // Read both streams on separate threads while the process runs
        std::thread stdout_reader([&]() {
            std::string line;
            while (std::getline(std_out, line))
                result.stdout_output += line + '\n';
        });
 
        std::thread stderr_reader([&]() {
            std::string line;
            while (std::getline(std_err, line))
                result.stderr_output += line + '\n';
        });
 
        child.wait();
        stdout_reader.join();
        stderr_reader.join();
 
        result.exit_code = child.exit_code();
    } catch (const std::exception&) {
        result.exit_code = -1;
    }
 
    return result;
}

References Slic3r::GUI::ProcessRunner::SyncResult::exit_code, Slic3r::GUI::ProcessRunner::SyncResult::stderr_output, and Slic3r::GUI::ProcessRunner::SyncResult::stdout_output.

start_reader_threads()

void Slic3r::GUI::ProcessRunner::start_reader_threads ( )

private

{
    join_reader_threads();
 
    if (m_stdout_pipe) {
        m_stdout_thread = std::thread([this]() {
            std::string line;
            while (std::getline(*m_stdout_pipe, line))
                enqueue_output(std::move(line), false);
        });
    }
 
    if (m_stderr_pipe) {
        m_stderr_thread = std::thread([this]() {
            std::string line;
            while (std::getline(*m_stderr_pipe, line))
                enqueue_output(std::move(line), true);
        });
    }
}

References enqueue_output(), join_reader_threads(), m_stderr_pipe, m_stderr_thread, m_stdout_pipe, and m_stdout_thread.

Referenced by run_command_line_async().

Here is the call graph for this function:

Here is the caller graph for this function:

terminate()

void Slic3r::GUI::ProcessRunner::terminate

(

)

{
    m_poll_timer.Stop();
 
    join_launch_thread();
 
    if (m_process && m_process->running()) {
        std::error_code ec;
        m_process->terminate(ec);
        m_process->wait(ec);
    }
 
    if (m_process) {
        finish_process(m_process->exit_code());
    } else if (m_launch_failed.exchange(false) || m_on_done) {
        finish_process(-1);
    }
}

References finish_process(), join_launch_thread(), m_launch_failed, m_on_done, m_poll_timer, and m_process.

Referenced by ~ProcessRunner().

Here is the call graph for this function:

Here is the caller graph for this function:

write_stdin()

void Slic3r::GUI::ProcessRunner::write_stdin

(

const std::string &

data

)

{
    if (m_launching.load() || !m_stdin_pipe || !m_process || !m_process->running())
        return;
 
    *m_stdin_pipe << data;
    m_stdin_pipe->flush();
}

References m_launching, m_process, and m_stdin_pipe.

Member Data Documentation

m_launch_failed

std::atomic_bool Slic3r::GUI::ProcessRunner::m_launch_failed {false}

private

{false};

Referenced by on_timer(), run_command_line_async(), and terminate().

m_launch_thread

std::thread Slic3r::GUI::ProcessRunner::m_launch_thread

private

Referenced by join_launch_thread(), and run_command_line_async().

m_launching

std::atomic_bool Slic3r::GUI::ProcessRunner::m_launching {false}

private

{false};

Referenced by is_running(), on_timer(), run_command_line_async(), and write_stdin().

m_on_done

DoneCallback Slic3r::GUI::ProcessRunner::m_on_done

private

Referenced by finish_process(), run_command_line_async(), and terminate().

m_on_output

OutputCallback Slic3r::GUI::ProcessRunner::m_on_output

private

Referenced by finish_process(), on_timer(), and run_command_line_async().

m_output_mutex

std::mutex Slic3r::GUI::ProcessRunner::m_output_mutex

private

Referenced by drain_output_queue(), and enqueue_output().

m_output_queue

std::vector<OutputLine> Slic3r::GUI::ProcessRunner::m_output_queue

private

Referenced by drain_output_queue(), and enqueue_output().

m_poll_timer

wxTimer Slic3r::GUI::ProcessRunner::m_poll_timer

private

Referenced by ProcessRunner(), on_timer(), run_command_line_async(), and terminate().

m_process

std::unique_ptr<boost::process::child> Slic3r::GUI::ProcessRunner::m_process

private

Referenced by finish_process(), is_running(), on_timer(), run_command_line_async(), terminate(), and write_stdin().

m_stderr_pipe

std::unique_ptr<boost::process::ipstream> Slic3r::GUI::ProcessRunner::m_stderr_pipe

private

Referenced by finish_process(), run_command_line_async(), and start_reader_threads().

m_stderr_thread

std::thread Slic3r::GUI::ProcessRunner::m_stderr_thread

private

Referenced by join_reader_threads(), and start_reader_threads().

m_stdin_pipe

std::unique_ptr<boost::process::opstream> Slic3r::GUI::ProcessRunner::m_stdin_pipe

private

Referenced by finish_process(), run_command_line_async(), and write_stdin().

m_stdout_pipe

std::unique_ptr<boost::process::ipstream> Slic3r::GUI::ProcessRunner::m_stdout_pipe

private

Referenced by finish_process(), run_command_line_async(), and start_reader_threads().

m_stdout_thread

std::thread Slic3r::GUI::ProcessRunner::m_stdout_thread

private

Referenced by join_reader_threads(), and start_reader_threads().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ProcessRunner.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ProcessRunner.cpp