Collaboration diagram for Slic3r::PrintHostJobQueue::priv:

Public Member Functions
	priv (PrintHostJobQueue *q)
void	emit_progress (int progress)
void	emit_error (wxString error)
void	emit_cancel (size_t id)
void	emit_info (wxString tag, wxString status)
void	start_bg_thread ()
void	stop_bg_thread ()
void	bg_thread_main ()
void	progress_fn (Http::Progress progress, bool &cancel)
void	error_fn (wxString error)
void	info_fn (wxString tag, wxString status)
void	remove_source (const fs::path &path)
void	remove_source ()
void	perform_job (PrintHostJob the_job)

Public Attributes
PrintHostJobQueue *	q
Channel< PrintHostJob >	channel_jobs
Channel< size_t >	channel_cancels
size_t	job_id = 0
int	prev_progress = -1
fs::path	source_to_remove
std::thread	bg_thread
bool	bg_exit = false
PrintHostQueueDialog *	queue_dialog

Detailed Description

Constructor & Destructor Documentation

◆ priv()

Slic3r::PrintHostJobQueue::priv::priv ( PrintHostJobQueue * q )

inline

245: q(q) {}

Slic3r::PrintHostJobQueue::priv::q

PrintHostJobQueue * q

Definition PrintHost.cpp:232

References Slic3r::PrintHostJobQueue::PrintHostJobQueue(), and q.

Here is the call graph for this function:

Member Function Documentation

◆ bg_thread_main()

void Slic3r::PrintHostJobQueue::priv::bg_thread_main ( )

{
    // bg thread entry point
 
    try {
        // Pick up jobs from the job channel:
        while (! bg_exit) {
            auto job = channel_jobs.pop();   // Sleeps in a cond var if there are no jobs
            if (job.empty()) {
                // This happens when the thread is being stopped
                break;
            }
 
            source_to_remove = job.upload_data.source_path;
 
            BOOST_LOG_TRIVIAL(debug) << boost::format("PrintHostJobQueue/bg_thread: Received job: [%1%]: `%2%` -> `%3%`, cancelled: %4%")
                % job_id
                % job.upload_data.upload_path
                % job.printhost->get_host()
                % job.cancelled;
 
            if (! job.cancelled) {
                perform_job(std::move(job));
            }
 
            remove_source();
            job_id++;
        }
    } catch (const std::exception &e) {
        emit_error(e.what());
    }
 
    // Cleanup leftover files, if any
    remove_source();
    auto jobs = channel_jobs.lock_rw();
    for (const PrintHostJob &job : *jobs) {
        remove_source(job.upload_data.source_path);
    }
}

References bg_exit, channel_jobs, emit_error(), job_id, perform_job(), remove_source(), and source_to_remove.

Here is the call graph for this function:

◆ emit_cancel()

void Slic3r::PrintHostJobQueue::priv::emit_cancel ( size_t id )

{
    auto evt = new PrintHostQueueDialog::Event(GUI::EVT_PRINTHOST_CANCEL, queue_dialog->GetId(), id);
    wxQueueEvent(queue_dialog, evt);
}

References queue_dialog.

Referenced by error_fn(), and progress_fn().

Here is the caller graph for this function:

◆ emit_error()

void Slic3r::PrintHostJobQueue::priv::emit_error ( wxString error )

{
    auto evt = new PrintHostQueueDialog::Event(GUI::EVT_PRINTHOST_ERROR, queue_dialog->GetId(), job_id, std::move(error));
    wxQueueEvent(queue_dialog, evt);
}

References job_id, and queue_dialog.

Referenced by bg_thread_main(), and error_fn().

Here is the caller graph for this function:

◆ emit_info()

void Slic3r::PrintHostJobQueue::priv::emit_info	(	wxString	tag,
		wxString	status )

{
    auto evt = new PrintHostQueueDialog::Event(GUI::EVT_PRINTHOST_INFO, queue_dialog->GetId(), job_id, std::move(tag), std::move(status));
    wxQueueEvent(queue_dialog, evt);
}

References job_id, and queue_dialog.

Referenced by info_fn().

Here is the caller graph for this function:

◆ emit_progress()

void Slic3r::PrintHostJobQueue::priv::emit_progress ( int progress )

{
    auto evt = new PrintHostQueueDialog::Event(GUI::EVT_PRINTHOST_PROGRESS, queue_dialog->GetId(), job_id, progress);
    wxQueueEvent(queue_dialog, evt);
}

References job_id, and queue_dialog.

Referenced by perform_job(), and progress_fn().

Here is the caller graph for this function:

◆ error_fn()

void Slic3r::PrintHostJobQueue::priv::error_fn ( wxString error )

{
    // check if transfer was not canceled before error occured - than do not show the error
    bool do_emit_err = true;
    if (channel_cancels.size_hint() > 0) {
        // Lock both queues
        auto cancels = channel_cancels.lock_rw();
        auto jobs = channel_jobs.lock_rw();
 
        for (size_t cancel_id : *cancels) {
            if (cancel_id == job_id) {
                do_emit_err = false;
                emit_cancel(job_id);
            }
            else if (cancel_id > job_id) {
                const size_t idx = cancel_id - job_id - 1;
                if (idx < jobs->size()) {
                    jobs->at(idx).cancelled = true;
                    BOOST_LOG_TRIVIAL(debug) << boost::format("PrintHostJobQueue: Job id %1% cancelled") % cancel_id;
                    emit_cancel(cancel_id);
                }
            }
        }
        cancels->clear();
    }
    if (do_emit_err)
        emit_error(std::move(error));
}

References channel_cancels, channel_jobs, emit_cancel(), emit_error(), and job_id.

Referenced by perform_job().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ info_fn()

void Slic3r::PrintHostJobQueue::priv::info_fn	(	wxString	tag,
		wxString	status )

{
    emit_info(tag, status);
}

References emit_info().

Referenced by perform_job().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ perform_job()

void Slic3r::PrintHostJobQueue::priv::perform_job ( PrintHostJob the_job )

{
    emit_progress(0);   // Indicate the upload is starting
 
    bool success = PrintHostJobQueue::upload_job(the_job,
        [this](Http::Progress progress, bool &cancel)   { this->progress_fn(std::move(progress), cancel); },
        [this](wxString error)                          { this->error_fn(std::move(error)); },
        [this](wxString tag, wxString host)             { this->info_fn(std::move(tag), std::move(host)); }
    );
 
    if (success) {
        emit_progress(100);
        if (the_job.switch_to_device_tab) {
            const auto mainframe = GUI::wxGetApp().mainframe;
            mainframe->request_select_tab(TAB_ID_MONITOR);
        }
    }
}

References Slic3r::PrintHostJobQueue::cancel(), emit_progress(), error_fn(), info_fn(), progress_fn(), Slic3r::PrintHostJob::switch_to_device_tab, TAB_ID_MONITOR, and Slic3r::PrintHostJobQueue::upload_job().

Referenced by bg_thread_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ progress_fn()

void Slic3r::PrintHostJobQueue::priv::progress_fn	(	Http::Progress	progress,
		bool &	cancel )

{
    if (cancel) {
        // When cancel is true from the start, Http indicates request has been cancelled
        emit_cancel(job_id);
        return;
    }
 
    if (bg_exit) {
        cancel = true;
        return;
    }
 
    if (channel_cancels.size_hint() > 0) {
        // Lock both queues
        auto cancels = channel_cancels.lock_rw();
        auto jobs = channel_jobs.lock_rw();
 
        for (size_t cancel_id : *cancels) {
            if (cancel_id == job_id) {
                cancel = true;
            } else if (cancel_id > job_id) {
                const size_t idx = cancel_id - job_id - 1;
                if (idx < jobs->size()) {
                    jobs->at(idx).cancelled = true;
                    BOOST_LOG_TRIVIAL(debug) << boost::format("PrintHostJobQueue: Job id %1% cancelled") % cancel_id;
                    emit_cancel(cancel_id);
                }
            }
        }
 
        cancels->clear();
    }
 
    if (! cancel) {
        int gui_progress = progress.ultotal > 0 ? 100*progress.ulnow / progress.ultotal : 0;
        if (gui_progress != prev_progress) {
            emit_progress(gui_progress);
            prev_progress = gui_progress;
        }
    }
}

References bg_exit, Slic3r::PrintHostJobQueue::cancel(), channel_cancels, channel_jobs, emit_cancel(), emit_progress(), job_id, prev_progress, Slic3r::Http::Progress::ulnow, and Slic3r::Http::Progress::ultotal.

Referenced by perform_job().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_source() [1/2]

void Slic3r::PrintHostJobQueue::priv::remove_source ( )

{
    remove_source(source_to_remove);
    source_to_remove.clear();
}

References remove_source(), and source_to_remove.

Here is the call graph for this function:

◆ remove_source() [2/2]

void Slic3r::PrintHostJobQueue::priv::remove_source ( const fs::path & path )

{
    if (! path.empty()) {
        boost::system::error_code ec;
        fs::remove(path, ec);
        if (ec) {
            BOOST_LOG_TRIVIAL(error) << boost::format("PrintHostJobQueue: Error removing file `%1%`: %2%") % path % ec;
        }
    }
}

Referenced by bg_thread_main(), and remove_source().

Here is the caller graph for this function:

◆ start_bg_thread()

void Slic3r::PrintHostJobQueue::priv::start_bg_thread ( )

{
    if (bg_thread.joinable()) { return; }
 
    std::shared_ptr<priv> p2 = q->p;
    bg_thread = std::thread([p2]() {
        p2->bg_thread_main();
    });
}

References bg_thread, and q.

◆ stop_bg_thread()

void Slic3r::PrintHostJobQueue::priv::stop_bg_thread ( )

{
    if (bg_thread.joinable()) {
        bg_exit = true;
        channel_jobs.push(PrintHostJob()); // Push an empty job to wake up bg_thread in case it's sleeping
        bg_thread.detach();                // Let the background thread go, it should exit on its own
    }
}