From 20a701641a27e4f8edae1c99c2a04d3d5207d6c6 Mon Sep 17 00:00:00 2001 From: Simon Quigley Date: Sun, 26 Jan 2025 17:56:13 -0600 Subject: [PATCH] General cleanup around task locking for a pkgconf --- cpp/ci_database_objs.cpp | 80 ++++++++++++++++++++++++++-------------- cpp/ci_database_objs.h | 2 + cpp/ci_logic.cpp | 12 ++++++ 3 files changed, 67 insertions(+), 27 deletions(-) diff --git a/cpp/ci_database_objs.cpp b/cpp/ci_database_objs.cpp index 410b0b4..8308269 100644 --- a/cpp/ci_database_objs.cpp +++ b/cpp/ci_database_objs.cpp @@ -678,34 +678,57 @@ int PackageConf::successful_task_count() { return successful_count; } -int PackageConf::total_task_count() { - std::lock_guard lock(*task_mutex_); +int PackageConf::successful_or_pending_task_count() { + int pending_count = 0; + { + std::lock_guard lock(*task_mutex_); + for (const auto& [job_status, task] : jobstatus_task_map_) { + if (task && task->start_time > 0 && task->finish_time == 0) { + ++pending_count; + } + } + } + return successful_task_count() + pending_count; +} - int successful_count = 0; - for (const auto& [job_status, task] : jobstatus_task_map_) if (task) ++successful_count; - return successful_count; +int PackageConf::successful_or_queued_task_count() { + int queued_count = 0; + { + std::lock_guard lock(*task_mutex_); + for (const auto& [job_status, task] : jobstatus_task_map_) { + if (task && task->queue_time > 0 && task->start_time == 0 && task->finish_time == 0) { + ++queued_count; + } + } + } + return successful_task_count() + queued_count; } -std::shared_ptr PackageConf::get_task_by_jobstatus(std::shared_ptr jobstatus) { - if (!jobstatus) { - throw std::invalid_argument("jobstatus is null"); +int PackageConf::total_task_count() { + int total_count = 0; + { + std::lock_guard lock(*task_mutex_); + for (const auto& [job_status, task] : jobstatus_task_map_) if (task) ++total_count; } + return total_count; +} - std::lock_guard lock(*task_mutex_); +std::shared_ptr PackageConf::get_task_by_jobstatus(std::shared_ptr jobstatus) { + if (!jobstatus) throw std::invalid_argument("jobstatus is null"); - // Search for the JobStatus in the map - auto it = jobstatus_task_map_.find(jobstatus); - if (it != jobstatus_task_map_.end()) { - return it->second; + { + std::lock_guard lock(*task_mutex_); + auto it = jobstatus_task_map_.find(jobstatus); + if (it != jobstatus_task_map_.end()) { + return it->second; + } } return nullptr; } void PackageConf::assign_task(std::shared_ptr jobstatus, std::shared_ptr task_ptr, std::weak_ptr packageconf_ptr) { - if (!jobstatus || !task_ptr) { - throw std::invalid_argument("jobstatus or task_ptr is null"); - } + if (!jobstatus || !task_ptr) throw std::invalid_argument("jobstatus or task_ptr is null"); std::lock_guard lock(*task_mutex_); task_ptr->parent_packageconf = task_ptr->parent_packageconf.lock() ? task_ptr->parent_packageconf : packageconf_ptr; @@ -876,20 +899,23 @@ bool PackageConf::can_check_source_upload() { std::int64_t upload_timestamp = 0; std::int64_t source_check_timestamp = 0; std::set valid_successful_statuses = {"pull", "tarball", "source_build", "upload"}; - for (auto &kv : jobstatus_task_map_) { - auto &jobstatus = kv.first; - auto &task_ptr = kv.second; + { + std::lock_guard lock(*task_mutex_); + for (auto &kv : jobstatus_task_map_) { + auto &jobstatus = kv.first; + auto &task_ptr = kv.second; - if (valid_successful_statuses.contains(jobstatus->name)) _successful_task_count--; + if (valid_successful_statuses.contains(jobstatus->name)) _successful_task_count--; - if (jobstatus->name == "upload" && task_ptr && task_ptr->successful) { - upload_timestamp = task_ptr->finish_time; - continue; - } + if (jobstatus->name == "upload" && task_ptr && task_ptr->successful) { + upload_timestamp = task_ptr->finish_time; + continue; + } - if (jobstatus->name == "source_check" && task_ptr && !task_ptr->successful) { - source_check_timestamp = task_ptr->finish_time; - continue; + if (jobstatus->name == "source_check" && task_ptr && !task_ptr->successful) { + source_check_timestamp = task_ptr->finish_time; + continue; + } } } bool all_req_tasks_present = _successful_task_count == 0; diff --git a/cpp/ci_database_objs.h b/cpp/ci_database_objs.h index dbd5c6a..41930da 100644 --- a/cpp/ci_database_objs.h +++ b/cpp/ci_database_objs.h @@ -162,6 +162,8 @@ public: const std::string& package_name); void assign_task(std::shared_ptr jobstatus, std::shared_ptr task_ptr, std::weak_ptr packageconf_ptr); int successful_task_count(); + int successful_or_pending_task_count(); + int successful_or_queued_task_count(); int total_task_count(); std::shared_ptr get_task_by_jobstatus(std::shared_ptr jobstatus); bool set_package_confs(); diff --git a/cpp/ci_logic.cpp b/cpp/ci_logic.cpp index 7ac3b7f..61ee12e 100644 --- a/cpp/ci_logic.cpp +++ b/cpp/ci_logic.cpp @@ -1140,10 +1140,22 @@ std::vector> CiLogic::get_config(const std::string } else if (sort_by == "build_status") { int a_successful_task_count = a->successful_task_count(); int b_successful_task_count = b->successful_task_count(); + int a_successful_or_pending_task_count = a->successful_or_pending_task_count(); + int b_successful_or_pending_task_count = b->successful_or_pending_task_count(); + int a_successful_or_queued_task_count = a->successful_or_queued_task_count(); + int b_successful_or_queued_task_count = b->successful_or_queued_task_count(); if (a_successful_task_count != b_successful_task_count) { return (order == "asc") ? (a_successful_task_count < b_successful_task_count) : (a_successful_task_count > b_successful_task_count); + } else if (a_successful_or_pending_task_count != b_successful_or_pending_task_count) { + return (order == "asc") + ? (a_successful_or_pending_task_count < b_successful_or_pending_task_count) + : (a_successful_or_pending_task_count > b_successful_or_pending_task_count); + } else if (a_successful_or_queued_task_count != b_successful_or_queued_task_count) { + return (order == "asc") + ? (a_successful_or_queued_task_count < b_successful_or_queued_task_count) + : (a_successful_or_queued_task_count > b_successful_or_queued_task_count); } else { return (order == "asc") ? (a->total_task_count() < b->total_task_count())