Slic3r::PrintHostJobQueue::priv Struct Reference

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

: q(q) {}

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);
    }
}

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);
}

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 error.

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);
}

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.

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 error.

info_fn()

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

{
    emit_info(tag, status);
}

perform_job()

void Slic3r::PrintHostJobQueue::priv::perform_job

(

PrintHostJob

the_job

)

{
    emit_progress(0);   // Indicate the upload is starting
 
    bool success = the_job.printhost->upload(std::move(the_job.upload_data),
        [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);
    }
}

References Slic3r::PrintHostJobQueue::cancel(), error, Slic3r::PrintHostJob::printhost, and Slic3r::PrintHostJob::upload_data.

Here is the call 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 Slic3r::PrintHostJobQueue::cancel(), Slic3r::Http::Progress::ulnow, and Slic3r::Http::Progress::ultotal.

Here is the call graph for this function:

remove_source() [1/2]

void Slic3r::PrintHostJobQueue::priv::remove_source

(

)

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

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;
        }
    }
}

References error.

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();
    });
}

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
    }
}

Member Data Documentation

bg_exit

bool Slic3r::PrintHostJobQueue::priv::bg_exit = false

bg_thread

std::thread Slic3r::PrintHostJobQueue::priv::bg_thread

channel_cancels

Channel<size_t> Slic3r::PrintHostJobQueue::priv::channel_cancels

channel_jobs

Channel<PrintHostJob> Slic3r::PrintHostJobQueue::priv::channel_jobs

job_id

size_t Slic3r::PrintHostJobQueue::priv::job_id = 0

Referenced by emit_progress().

prev_progress

int Slic3r::PrintHostJobQueue::priv::prev_progress = -1

q

PrintHostJobQueue* Slic3r::PrintHostJobQueue::priv::q

queue_dialog

PrintHostQueueDialog* Slic3r::PrintHostJobQueue::priv::queue_dialog

Referenced by emit_progress().

source_to_remove

fs::path Slic3r::PrintHostJobQueue::priv::source_to_remove

---

The documentation for this struct was generated from the following file:

• src/slic3r/Utils/PrintHost.cpp