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

Collaboration diagram for Slic3r::TaskManager:

Public Member Functions
	TaskManager (NetworkAgent *agent)
void	set_agent (NetworkAgent *agent)
int	start_print (const std::vector< PrintParams > &params, TaskSettings *settings=nullptr)
void	start ()
void	stop ()
std::map< int, TaskStateInfo * >	get_local_task_list ()
std::map< std::string, TaskStateInfo >	get_task_list (int curr_page, int page_count, int &total)
TaskState	query_task_state (std::string dev_id)

Static Public Member Functions
static void	set_max_send_at_same_time (int count)

Static Public Attributes
static int	MaxSendingAtSameTime = 5
static int	SendingInterval = 180

Private Member Functions
int	schedule (TaskStateInfo *task)

Private Attributes
boost::thread	m_scedule_thread
std::vector< TaskGroup >	m_cache_map
std::mutex	m_map_mutex
std::vector< TaskStateInfo * >	m_scedule_list
std::vector< boost::thread * >	m_sending_thread_list
std::mutex	m_scedule_mutex
bool	m_started { false }
std::atomic< NetworkAgent * >	m_agent { nullptr }
std::chrono::system_clock::time_point	last_sent_timestamp

Detailed Description

Constructor & Destructor Documentation

◆ TaskManager()

Slic3r::TaskManager::TaskManager ( NetworkAgent * agent )

    :m_agent(agent)
{
    ;
}

References m_agent.

Member Function Documentation

◆ get_local_task_list()

std::map< int, TaskStateInfo * > Slic3r::TaskManager::get_local_task_list ( )

{
    std::map<int, TaskStateInfo*> out;
    m_map_mutex.lock();
    for (auto it = m_cache_map.begin(); it != m_cache_map.end(); it++) {
        for (auto iter = (*it).tasks.begin(); iter != (*it).tasks.end(); iter++) {
            if ((*iter)->state() == TaskState::TS_PENDING
                || (*iter)->state() == TaskState::TS_SENDING
                || (*iter)->state() == TaskState::TS_SEND_CANCELED
                || (*iter)->state() == TaskState::TS_SEND_COMPLETED
                || (*iter)->state() == TaskState::TS_SEND_FAILED) {
                out.insert(std::make_pair((*iter)->task_info_id, *iter));
            }
        }
    }
    m_map_mutex.unlock();
    return out;
}

References m_cache_map, m_map_mutex, Slic3r::TS_PENDING, Slic3r::TS_SEND_CANCELED, Slic3r::TS_SEND_COMPLETED, Slic3r::TS_SEND_FAILED, and Slic3r::TS_SENDING.

◆ get_task_list()

std::map< std::string, TaskStateInfo > Slic3r::TaskManager::get_task_list	(	int	curr_page,
		int	page_count,
		int &	total )

{
    std::map<std::string, TaskStateInfo> out;
    NetworkAgent* agent = m_agent;
    if (agent) {
        TaskQueryParams task_query_params;
        task_query_params.limit = page_count;
        task_query_params.offset = curr_page * page_count;
        std::string task_info;
        int result = agent->get_user_tasks(task_query_params, &task_info, GUI::wxGetApp().get_printer_cloud_provider());
        BOOST_LOG_TRIVIAL(trace) << "task_manager: get_task_list task_info=" << task_info;
        if (result == 0) {
            try {
                json j = json::parse(task_info);
                if (j.contains("total")) {
                    total = j["total"].get<int>();
                }
                if (!j.contains("hits")) {
                    return out;
                }
                BOOST_LOG_TRIVIAL(trace) << "task_manager: get_task_list task count =" << j["hits"].size();
                for (auto& hit : j["hits"]) {
                    TaskStateInfo task_info;
                    int64_t design_id = 0;
                    if (hit.contains("designId")) {
                        design_id = hit["designId"].get<int64_t>();
                    }
                    if (design_id > 0 && hit.contains("designTitle")) {
                        task_info.set_task_name(hit["designTitle"].get<std::string>());
                    } else {
                        if (hit.contains("title"))
                            task_info.set_task_name(hit["title"].get<std::string>());
                    }
                    if (hit.contains("deviceName"))
                        task_info.set_device_name(hit["deviceName"].get<std::string>());
                    if (hit.contains("deviceId"))
                        task_info.params().dev_id = hit["deviceId"].get<std::string>();
                    if (hit.contains("id"))
                        task_info.set_job_id(std::to_string(hit["id"].get<int64_t>()));
                    if (hit.contains("status"))
                        task_info.set_state(parse_task_status(hit["status"].get<int>()));
                    if (hit.contains("cover"))
                        task_info.thumbnail_url = hit["cover"].get<std::string>();
                    if (hit.contains("startTime"))
                        task_info.start_time = hit["startTime"].get<std::string>();
                    if (hit.contains("endTime"))
                        task_info.end_time = hit["endTime"].get<std::string>();
                    if (hit.contains("profileId"))
                        task_info.profile_id = std::to_string(hit["profileId"].get<int64_t>());
                    if (!task_info.get_job_id().empty())
                        out.insert(std::make_pair(task_info.get_job_id(), task_info));
                }
            }
            catch(...) {
            }
        }
    }
    return out;
}

Here is the call graph for this function:

◆ query_task_state()

TaskState Slic3r::TaskManager::query_task_state ( std::string dev_id )

{
    /* priority: TS_SENDING > TS_PENDING > TS_IDLE */
    TaskState ts = TaskState::TS_IDLE;
    m_map_mutex.lock();
    for (auto& task_group : m_cache_map) {
        for (auto it = task_group.tasks.begin(); it != task_group.tasks.end(); it++) {
            if ((*it)->params().dev_id == dev_id) {
                if ((*it)->state() == TS_SENDING) {
                    m_map_mutex.unlock();
                    return TS_SENDING;
                } else if ((*it)->state() == TS_PENDING) {
                    ts = TS_PENDING;
                }
            }
        }
    }
    m_map_mutex.unlock();
    return ts;
}

References m_cache_map, m_map_mutex, Slic3r::TS_IDLE, Slic3r::TS_PENDING, and Slic3r::TS_SENDING.

◆ schedule()

int Slic3r::TaskManager::schedule ( TaskStateInfo * task )

private

{
    if (!m_agent) {
        assert(false);
        return -1;
    }
    if (task->state() != TaskState::TS_PENDING)
        return 0;
    assert(task->state() == TaskState::TS_PENDING);
    task->set_state(TaskState::TS_SENDING);
 
    BOOST_LOG_TRIVIAL(trace) << "task_manager: schedule a task to dev_id = " << task->params().dev_id;
    boost::thread* new_sending_thread = new boost::thread();
    *new_sending_thread = Slic3r::create_thread(
        [this, task] {
            // Keep both lifecycle callbacks on this per-task worker thread. Plugin observers can
            // therefore associate Started and Finished for one task with a single execution context.
            LifecycleEventContext start_ctx;
            start_ctx.name = task->params().project_name;
            start_ctx.device_id = task->params().dev_id;
            start_ctx.job_id = std::to_string(task->task_info_id);
            start_ctx.source = "task_manager";
            fire_lifecycle_event(LifecycleEvent::PrintJobStarted, start_ctx);
 
            int result = -1;
            NetworkAgent* agent = m_agent;
            if (!agent) {
                BOOST_LOG_TRIVIAL(trace) << "task_manager: NetworkAgent is nullptr";
            }
            else {
                assert(agent);
                try {
// DEBUG FOR TEST
#if 0
                    result = start_print_test(task->get_params(), task->update_status_fn, task->cancel_fn, task->wait_fn);
#else
                    result = agent->start_print(task->get_params(), task->update_status_fn, task->cancel_fn, task->wait_fn);
#endif
                } catch (const std::exception& ex) {
                    BOOST_LOG_TRIVIAL(error) << "task_manager: start_print threw: " << ex.what();
                } catch (...) {
                    BOOST_LOG_TRIVIAL(error) << "task_manager: start_print threw an unknown exception";
                }
            }
            if (result == 0) {
                last_sent_timestamp = std::chrono::system_clock::now();
                task->set_sent_time(last_sent_timestamp);
                task->set_state(TaskState::TS_SEND_COMPLETED);
            }
            else {
                if (!task->is_canceled()) {
                    task->set_state(TaskState::TS_SEND_FAILED);
                } else {
                    task->set_state(TaskState::TS_SEND_CANCELED);
                }
            }
 
            LifecycleEventContext finish_ctx;
            finish_ctx.name = task->params().project_name;
            finish_ctx.device_id = task->params().dev_id;
            finish_ctx.job_id = std::to_string(task->task_info_id);
            finish_ctx.source = "task_manager";
            finish_ctx.code = result == 0 ? LifecycleEvtCode::Ok :
                (task->is_canceled() ? LifecycleEvtCode::Warn : LifecycleEvtCode::Error);
            finish_ctx.msg = result == 0 ? "" : (task->is_canceled() ? "cancelled" : "failed");
            fire_lifecycle_event(LifecycleEvent::PrintJobFinished, finish_ctx);
     
            /* remove from sending task list */
            m_scedule_mutex.lock();
            auto it = std::find(m_scedule_list.begin(), m_scedule_list.end(), task);
            if (it != m_scedule_list.end()) {
                BOOST_LOG_TRIVIAL(trace) << "task_manager: schedule, scedule task has removed from list";
                m_scedule_list.erase(it);
            }
            else {
                /*assert(false);*/
            }
            m_scedule_mutex.unlock();
        }
    );
    m_sending_thread_list.push_back(new_sending_thread);
    return 0;
}

References Slic3r::TaskStateInfo::cancel_fn, Slic3r::LifecycleEventContext::code, Slic3r::create_thread(), Slic3r::PrintParams::dev_id, Slic3r::LifecycleEventContext::device_id, Slic3r::Error, Slic3r::fire_lifecycle_event(), Slic3r::TaskStateInfo::get_params(), Slic3r::TaskStateInfo::is_canceled(), Slic3r::LifecycleEventContext::job_id, last_sent_timestamp, m_agent, m_scedule_list, m_scedule_mutex, m_sending_thread_list, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Ok, Slic3r::TaskStateInfo::params(), Slic3r::PrintJobFinished, Slic3r::PrintJobStarted, Slic3r::PrintParams::project_name, Slic3r::TaskStateInfo::set_sent_time(), Slic3r::TaskStateInfo::set_state(), Slic3r::LifecycleEventContext::source, Slic3r::NetworkAgent::start_print(), Slic3r::start_print_test(), Slic3r::TaskStateInfo::state(), Slic3r::TaskStateInfo::task_info_id, Slic3r::trace(), Slic3r::TS_PENDING, Slic3r::TS_SEND_CANCELED, Slic3r::TS_SEND_COMPLETED, Slic3r::TS_SEND_FAILED, Slic3r::TS_SENDING, Slic3r::TaskStateInfo::update_status_fn, Slic3r::TaskStateInfo::wait_fn, and Slic3r::Warn.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_agent()

void Slic3r::TaskManager::set_agent ( NetworkAgent * agent )

{
    m_agent = agent;
}

References m_agent.

◆ set_max_send_at_same_time()

void Slic3r::TaskManager::set_max_send_at_same_time ( int count )

static

{
    TaskManager::MaxSendingAtSameTime = count;
}

References count, and MaxSendingAtSameTime.

◆ start()

void Slic3r::TaskManager::start ( )

{
    if (m_started) {
        return;
    }
    m_started = true;
    m_scedule_thread = Slic3r::create_thread(
        [this] {
        BOOST_LOG_TRIVIAL(trace) << "task_manager: thread start()";
        while (m_started) {
            m_map_mutex.lock();
            for (auto it = m_cache_map.begin(); it != m_cache_map.end(); it++) {
                for (auto iter = it->tasks.begin(); iter != it->tasks.end(); iter++) {
                    m_scedule_mutex.lock();
                    if (m_scedule_list.size() < TaskManager::MaxSendingAtSameTime
                        && it->need_schedule(last_sent_timestamp, *iter)) {
                        m_scedule_list.push_back(*iter);
                    }
                    m_scedule_mutex.unlock();
                }
            }
            m_map_mutex.unlock();
            if (!m_scedule_list.empty()) {
                //BOOST_LOG_TRIVIAL(trace) << "task_manager: need scedule task count = " << m_scedule_list.size();
                m_scedule_mutex.lock();
                for (auto it = m_scedule_list.begin(); it != m_scedule_list.end(); it++) {
                    this->schedule(*it);
                }
                m_scedule_mutex.unlock();
            }
            boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
        }
        BOOST_LOG_TRIVIAL(trace) << "task_manager: thread exit()";
    });
}

References Slic3r::create_thread(), last_sent_timestamp, m_cache_map, m_map_mutex, m_scedule_list, m_scedule_mutex, m_scedule_thread, m_started, MaxSendingAtSameTime, schedule(), and Slic3r::trace().

Here is the call graph for this function:

◆ start_print()

int Slic3r::TaskManager::start_print	(	const std::vector< PrintParams > &	params,
		TaskSettings *	settings = nullptr )

{
    BOOST_LOG_TRIVIAL(info) << "task_manager: start_print size = " << params.size();
    TaskManager::MaxSendingAtSameTime = settings->max_sending_at_same_time;
    TaskManager::SendingInterval = settings->sending_interval;
    m_map_mutex.lock();
    TaskGroup task_group(*settings);
    task_group.tasks.reserve(params.size());
    for (auto it = params.begin(); it != params.end(); it++) {
        TaskStateInfo* new_item = new TaskStateInfo(*it);
        task_group.append(new_item);
    }
    m_cache_map.push_back(task_group);
    m_map_mutex.unlock();
    return 0;
}

References Slic3r::TaskGroup::append(), m_cache_map, m_map_mutex, Slic3r::TaskSettings::max_sending_at_same_time, MaxSendingAtSameTime, Slic3r::TaskSettings::sending_interval, SendingInterval, and Slic3r::TaskGroup::tasks.

Here is the call graph for this function:

◆ stop()

void Slic3r::TaskManager::stop ( )

{
    m_started = false;
    if (m_scedule_thread.joinable())
        m_scedule_thread.join();
}

References m_scedule_thread, and m_started.

Member Data Documentation

◆ last_sent_timestamp

std::chrono::system_clock::time_point Slic3r::TaskManager::last_sent_timestamp

private

Referenced by schedule(), and start().

◆ m_agent

std::atomic<NetworkAgent*> Slic3r::TaskManager::m_agent { nullptr }

private

191{ nullptr };

Referenced by TaskManager(), get_task_list(), schedule(), and set_agent().

◆ m_cache_map

std::vector<TaskGroup> Slic3r::TaskManager::m_cache_map

private

Referenced by get_local_task_list(), query_task_state(), start(), and start_print().

◆ m_map_mutex

std::mutex Slic3r::TaskManager::m_map_mutex

private

Referenced by get_local_task_list(), query_task_state(), start(), and start_print().

◆ m_scedule_list

std::vector<TaskStateInfo*> Slic3r::TaskManager::m_scedule_list

private

Referenced by schedule(), and start().

◆ m_scedule_mutex

std::mutex Slic3r::TaskManager::m_scedule_mutex

private

Referenced by schedule(), and start().

◆ m_scedule_thread

boost::thread Slic3r::TaskManager::m_scedule_thread

private

Referenced by start(), and stop().

◆ m_sending_thread_list

std::vector<boost::thread*> Slic3r::TaskManager::m_sending_thread_list

private

Referenced by schedule().

◆ m_started

bool Slic3r::TaskManager::m_started { false }

private

189{ false };

Referenced by start(), and stop().

◆ MaxSendingAtSameTime

int Slic3r::TaskManager::MaxSendingAtSameTime = 5

static

Referenced by set_max_send_at_same_time(), start(), start_print(), and Slic3r::wxDEFINE_EVENT().

◆ SendingInterval

int Slic3r::TaskManager::SendingInterval = 180

static

Referenced by Slic3r::TaskGroup::need_schedule(), start_print(), and Slic3r::wxDEFINE_EVENT().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/TaskManager.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/TaskManager.cpp

	OrcaSlicer latest OrcaSlicer

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TaskManager()

Member Function Documentation

◆ get_local_task_list()

◆ get_task_list()

◆ query_task_state()

◆ schedule()

◆ set_agent()

◆ set_max_send_at_same_time()

◆ start()

◆ start_print()

◆ stop()

Member Data Documentation

◆ last_sent_timestamp

◆ m_agent

◆ m_cache_map

◆ m_map_mutex

◆ m_scedule_list

◆ m_scedule_mutex

◆ m_scedule_thread

◆ m_sending_thread_list

◆ m_started

◆ MaxSendingAtSameTime

◆ SendingInterval