General cleanup around task locking for a pkgconf

cpp/ci_database_objs.cpp

@@ -678,34 +678,57 @@ int PackageConf::successful_task_count() {
     return successful_count;
 }
 
-int PackageConf::total_task_count() {
+int PackageConf::successful_or_pending_task_count() {
+    int pending_count = 0;
+    {
         std::lock_guard<std::mutex> 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;
+int PackageConf::successful_or_queued_task_count() {
-    for (const auto& [job_status, task] : jobstatus_task_map_) if (task) ++successful_count;
+    int queued_count = 0;
-    return successful_count;
+    {
+        std::lock_guard<std::mutex> 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;
+}
+
+int PackageConf::total_task_count() {
+    int total_count = 0;
+    {
+        std::lock_guard<std::mutex> lock(*task_mutex_);
+        for (const auto& [job_status, task] : jobstatus_task_map_) if (task) ++total_count;
+    }
+    return total_count;
 }
 
 std::shared_ptr<Task> PackageConf::get_task_by_jobstatus(std::shared_ptr<JobStatus> jobstatus) {
-    if (!jobstatus) {
+    if (!jobstatus) throw std::invalid_argument("jobstatus is null");
-        throw std::invalid_argument("jobstatus is null");
-    }
 
+    {
         std::lock_guard<std::mutex> lock(*task_mutex_);
-
-    // Search for the JobStatus in the map
         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> jobstatus, std::shared_ptr<Task> task_ptr, std::weak_ptr<PackageConf> packageconf_ptr) {
-    if (!jobstatus || !task_ptr) {
+    if (!jobstatus || !task_ptr) throw std::invalid_argument("jobstatus or task_ptr is null");
-        throw std::invalid_argument("jobstatus or task_ptr is null");
-    }
 
     std::lock_guard<std::mutex> lock(*task_mutex_);
     task_ptr->parent_packageconf = task_ptr->parent_packageconf.lock() ? task_ptr->parent_packageconf : packageconf_ptr;
@@ -876,6 +899,8 @@ bool PackageConf::can_check_source_upload() {
     std::int64_t upload_timestamp = 0;
     std::int64_t source_check_timestamp = 0;
     std::set<std::string> valid_successful_statuses = {"pull", "tarball", "source_build", "upload"};
+    {
+        std::lock_guard<std::mutex> lock(*task_mutex_);
         for (auto &kv : jobstatus_task_map_) {
             auto &jobstatus = kv.first;
             auto &task_ptr = kv.second;
@@ -892,6 +917,7 @@ bool PackageConf::can_check_source_upload() {
                 continue;
             }
         }
+    }
     bool all_req_tasks_present = _successful_task_count == 0;
     if (!all_req_tasks_present || (upload_timestamp == 0 && source_check_timestamp == 0)) {
         return false;

cpp/ci_database_objs.h

@@ -162,6 +162,8 @@ public:
                                                                                 const std::string& package_name);
     void assign_task(std::shared_ptr<JobStatus> jobstatus, std::shared_ptr<Task> task_ptr, std::weak_ptr<PackageConf> 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<Task> get_task_by_jobstatus(std::shared_ptr<JobStatus> jobstatus);
     bool set_package_confs();

cpp/ci_logic.cpp

@@ -1140,10 +1140,22 @@ std::vector<std::shared_ptr<PackageConf>> 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())