update

Author: namchuai

engine/common/download_event.h

@@ -38,17 +38,9 @@ std::string DownloadEventTypeToString(DownloadEventType type) {
 }
 }  // namespace
 
-class DownloadEvent : public cortex::event::Event {
- public:
-  explicit DownloadEvent(DownloadEventType type, const DownloadTask task)
-      : type_{type}, download_task_{task} {}
+struct DownloadEvent : public cortex::event::Event {
+  std::string ToString() const { return download_task_.ToString(); }
 
-  std::string ToString() const {
-    return "DownloadEvent: " + DownloadEventTypeToString(type_) +
-           " task: " + download_task_.ToString();
-  }
-
- private:
   DownloadEventType type_;
   DownloadTask download_task_;
 };

engine/common/download_task.h

@@ -20,10 +20,14 @@ struct DownloadItem {
 
   std::optional<uint64_t> bytes;
 
+  std::optional<uint64_t> downloadedBytes;
+
   std::string ToString() const {
     std::ostringstream output;
     output << "DownloadItem{id: " << id << ", downloadUrl: " << downloadUrl
            << ", localContainerPath: " << localPath
+           << ", bytes: " << bytes.value_or(0)
+           << ", downloadedBytes: " << downloadedBytes.value_or(0)
            << ", checksum: " << checksum.value_or("N/A") << "}";
     return output.str();
   }
@@ -46,6 +50,21 @@ struct DownloadTask {
     output << "]}";
     return output.str();
   }
-
-  // TODO: namh implement ToJson()
 };
+
+inline std::string DownloadTypeToString(DownloadType type) {
+  switch (type) {
+    case DownloadType::Model:
+      return "Model";
+    case DownloadType::Engine:
+      return "Engine";
+    case DownloadType::Miscellaneous:
+      return "Miscellaneous";
+    case DownloadType::CudaToolkit:
+      return "CudaToolkit";
+    case DownloadType::Cortex:
+      return "Cortex";
+    default:
+      return "Unknown";
+  }
+}

engine/common/event.h

@@ -2,8 +2,5 @@
 
 namespace cortex::event {
 
-class Event {
- public:
-  virtual ~Event() {}
-};
+struct Event {};
 }  // namespace cortex::event

engine/common/hardward_event.h

@@ -232,7 +232,7 @@ cpp::result<bool, std::string> DownloadService::Download(
   curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
 
-  curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progressCallback);
+  curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, ProgressCallback);
   curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, this);
 
   if (mode == "ab") {

engine/common/model_event.h

@@ -57,29 +57,41 @@ class DownloadService {
   std::optional<std::string> active_download_task_id_;
   std::optional<std::string> active_download_item_id_;
 
+  /**
+   * Invoked when download is completed (both failed or success)
+   */
   void CleanUp(const std::string& task_id);
 
-  static int progressCallback(void* ptr, double dltotal, double dlnow,
+  static int ProgressCallback(void* ptr, double dltotal, double dlnow,
                               double ultotal, double ulnow) {
     DownloadService* service = static_cast<DownloadService*>(ptr);
-    double progress = (dltotal > 0) ? (dlnow / dltotal * 100.0) : 0.0;
-
     auto event_queue = service->event_queue_.value();
     if (event_queue == nullptr) {
       return 0;
     }
 
-    if (service->active_download_task_id_.has_value() &&
-        service->active_download_item_id_.has_value()) {
+    auto active_task_id = service->active_download_task_id_;
+    auto active_item_id = service->active_download_item_id_;
+    if (!active_task_id.has_value() || !active_item_id.has_value()) {
+      return 0;
+    }
+
+    auto task = service->download_task_map_[active_task_id.value()];
 
-      auto task =
-          service
-              ->download_task_map_[service->active_download_task_id_.value()];
-      auto dl_evt = DownloadEvent(
-          cortex::event::DownloadEventType::DownloadUpdated, task);
-      event_queue->enqueue("download-update", dl_evt);
+    // loop through download items, find the active one and update it
+    for (auto& item : task.items) {
+      if (item.id == active_item_id.value()) {
+        item.downloadedBytes = dlnow;
+        item.bytes = dltotal;
+        break;
+      }
     }
 
+    event_queue->enqueue(
+        "download-update",
+        DownloadEvent{
+            .type_ = cortex::event::DownloadEventType::DownloadUpdated,
+            .download_task_ = task});
     return 0;
   }
 };