add update engine

engine/cli/commands/engine_install_cmd.cc

@@ -1,7 +1,6 @@
 #include "engine_install_cmd.h"
 #include "server_start_cmd.h"
 #include "utils/download_progress.h"
-#include "utils/engine_constants.h"
 #include "utils/json_helper.h"
 #include "utils/logging_utils.h"
 
@@ -33,7 +32,7 @@ bool EngineInstallCmd::Exec(const std::string& engine,
 
   httplib::Client cli(host_ + ":" + std::to_string(port_));
   Json::Value json_data;
-  json_data["version"] =  version.empty() ? "latest" : version;
+  json_data["version"] = version.empty() ? "latest" : version;
   auto data_str = json_data.toStyledString();
   cli.set_read_timeout(std::chrono::seconds(60));
   auto res = cli.Post("/v1/engines/install/" + engine, httplib::Headers(),

engine/common/event.h

@@ -85,7 +85,7 @@ inline DownloadEvent GetDownloadEventFromJson(const Json::Value& item_json) {
   }
   return ev;
 }
-};  // namespace cortex::event
+}  // namespace cortex::event
 
 constexpr std::size_t eventMaxSize =
     eventpp::maxSizeOf<cortex::event::Event, cortex::event::DownloadEvent,

engine/controllers/engines.cc

@@ -63,14 +63,10 @@ void Engines::ListEngine(
                                              kTrtLlmEngine};
   Json::Value ret;
   for (const auto& engine : supported_engines) {
-    std::cout << engine << std::endl;
-
-    auto result = engine_service_->GetInstalledEngineVariants(engine);
-    if (result.has_error()) {
-      continue;
-    }
+    auto installed_engines =
+        engine_service_->GetInstalledEngineVariants(engine);
     Json::Value variants(Json::arrayValue);
-    for (const auto& variant : result.value()) {
+    for (const auto& variant : installed_engines) {
       variants.append(variant.ToJson());
     }
     ret[engine] = variants;
@@ -205,34 +201,39 @@ void Engines::GetEnginesInstalledVariants(
     std::function<void(const HttpResponsePtr&)>&& callback,
     const std::string& engine) const {
   auto result = engine_service_->GetInstalledEngineVariants(engine);
+  Json::Value releases(Json::arrayValue);
+  for (const auto& variant : result) {
+    releases.append(variant.ToJson());
+  }
+  auto resp = cortex_utils::CreateCortexHttpJsonResponse(releases);
+  resp->setStatusCode(k200OK);
+  callback(resp);
+}
+
+void Engines::UpdateEngine(
+    const HttpRequestPtr& req,
+    std::function<void(const HttpResponsePtr&)>&& callback,
+    const std::string& engine) {
+  auto result = engine_service_->UpdateEngine(engine);
   if (result.has_error()) {
     Json::Value res;
     res["message"] = result.error();
     auto resp = cortex_utils::CreateCortexHttpJsonResponse(res);
     resp->setStatusCode(k400BadRequest);
     callback(resp);
   } else {
-    Json::Value releases(Json::arrayValue);
-    for (const auto& variant : result.value()) {
-      releases.append(variant.ToJson());
-    }
-    auto resp = cortex_utils::CreateCortexHttpJsonResponse(releases);
+    auto resp =
+        cortex_utils::CreateCortexHttpJsonResponse(result.value().ToJson());
     resp->setStatusCode(k200OK);
     callback(resp);
   }
 }
 
-void Engines::UpdateEngine(
-    const HttpRequestPtr& req,
-    std::function<void(const HttpResponsePtr&)>&& callback,
-    const std::string& engine) {}
-
 void Engines::GetLatestEngineVersion(
     const HttpRequestPtr& req,
     std::function<void(const HttpResponsePtr&)>&& callback,
     const std::string& engine) {
   auto result = engine_service_->GetLatestEngineVersion(engine);
-  std::cout << result->ToJson() << std::endl;
   if (result.has_error()) {
     Json::Value res;
     res["message"] = result.error();

engine/controllers/engines.h

@@ -13,7 +13,7 @@ class Engines : public drogon::HttpController<Engines, false> {
   METHOD_LIST_BEGIN
 
   // TODO: update this API
-  METHOD_ADD(Engines::InstallEngine, "/install/{1}", Post);
+  // METHOD_ADD(Engines::InstallEngine, "/install/{1}", Post);
   METHOD_ADD(Engines::UninstallEngine, "/{1}/{2}/{3}", Delete);
   METHOD_ADD(Engines::ListEngine, "", Get);
 
@@ -22,7 +22,7 @@ class Engines : public drogon::HttpController<Engines, false> {
   METHOD_ADD(Engines::InstallEngineVariant, "/{1}/versions/{2}/{3}", Post);
   METHOD_ADD(Engines::GetEnginesInstalledVariants, "/{1}", Get);
 
-  METHOD_ADD(Engines::GetLatestEngineVersion, "/{1}/update", Get);
+  // METHOD_ADD(Engines::GetLatestEngineVersion, "/{1}/update", Get);
   METHOD_ADD(Engines::UpdateEngine, "/{1}/update", Post);
   METHOD_ADD(Engines::SetDefaultEngineVariant, "/{1}/default/{2}/{3}", Post);
   METHOD_ADD(Engines::GetDefaultEngineVariant, "/{1}/default", Get);

engine/database/models.cc

@@ -178,7 +178,6 @@ cpp::result<bool, std::string> Models::AddModelEntry(ModelEntry new_entry,
     auto model_list = LoadModelListNoLock();
     if (model_list.has_error()) {
       CTL_WRN(model_list.error());
-      std::cout << "Test: " << model_list.error();
       return cpp::fail(model_list.error());
     }
     if (IsUnique(model_list.value(), new_entry.model, new_entry.model_alias)) {

engine/services/engine_service.cc

@@ -1,7 +1,6 @@
 #include "engine_service.h"
 #include <cstdlib>
 #include <filesystem>
-#include <iostream>
 #include <optional>
 #include "algorithm"
 #include "utils/archive_utils.h"
@@ -74,6 +73,9 @@ cpp::result<void, std::string> EngineService::InstallEngineAsyncV2(
     const std::string& engine, const std::string& version,
     const std::string& variant_name) {
   auto ne = NormalizeEngine(engine);
+  CTL_INF("InstallEngineAsyncV2: " << ne << ", " << version << ", "
+                                   << variant_name);
+
   auto result = DownloadEngineV2(ne, version, variant_name, true /*async*/);
   if (result.has_error()) {
     return result;
@@ -173,7 +175,6 @@ cpp::result<bool, std::string> EngineService::UninstallEngineVariant(
   auto ne = NormalizeEngine(engine);
   auto engine_path =
       file_manager_utils::GetEnginesContainerPath() / ne / variant / version;
-  std::cout << "engine_path: " << engine_path.string() << std::endl;
   if (!std::filesystem::exists(engine_path)) {
     return cpp::fail("Engine " + ne + " is not installed!");
   }
@@ -259,7 +260,7 @@ cpp::result<void, std::string> EngineService::DownloadEngineV2(
                        .downloadUrl = selected_variant->browser_download_url,
                        .localPath = variant_path,
                    }}}};
-  std::cout << downloadTask.ToString() << std::endl;
+
   auto add_task_result = download_service_->AddTask(downloadTask, on_finished);
   if (res.has_error()) {
     return cpp::fail(res.error());
@@ -540,12 +541,8 @@ cpp::result<bool, std::string> EngineService::IsEngineVariantReady(
   auto ne = NormalizeEngine(engine);
   auto normalized_version = string_utils::RemoveSubstring(version, "v");
   auto installed_engines = GetInstalledEngineVariants(ne);
-  if (installed_engines.has_error()) {
-    return cpp::fail("Failed to get installed engines: " +
-                     installed_engines.error());
-  }
 
-  for (const auto& installed_engine : installed_engines.value()) {
+  for (const auto& installed_engine : installed_engines) {
     if (installed_engine.name == variant &&
         installed_engine.version == normalized_version) {
       return true;
@@ -564,8 +561,8 @@ EngineService::GetDefaultEngineVariant(const std::string& engine) {
   return default_variants_[ne];
 }
 
-cpp::result<std::vector<EngineVariantResponse>, std::string>
-EngineService::GetInstalledEngineVariants(const std::string& engine) const {
+std::vector<EngineVariantResponse> EngineService::GetInstalledEngineVariants(
+    const std::string& engine) const {
   auto ne = NormalizeEngine(engine);
   auto engines_variants_dir =
       file_manager_utils::GetEnginesContainerPath() / ne;
@@ -774,12 +771,6 @@ cpp::result<bool, std::string> EngineService::IsEngineReady(
     const std::string& engine) const {
   auto ne = NormalizeEngine(engine);
   auto installed_variants = GetInstalledEngineVariants(engine);
-  if (installed_variants.has_error()) {
-    CTL_WRN("Failed to get installed engine variants: " +
-            installed_variants.error());
-    return cpp::fail("Failed to get installed engine variants: " +
-                     installed_variants.error());
-  }
 
   auto os = hw_inf_.sys_inf->os;
   if (os == kMacOs && (ne == kOnnxRepo || ne == kTrtLlmRepo)) {
@@ -790,5 +781,62 @@ cpp::result<bool, std::string> EngineService::IsEngineReady(
     return cpp::fail("Engine " + engine + " is not supported on Linux");
   }
 
-  return installed_variants.value().size() > 0;
+  return installed_variants.size() > 0;
+}
+
+cpp::result<EngineUpdateResult, std::string> EngineService::UpdateEngine(
+    const std::string& engine) {
+  auto ne = NormalizeEngine(engine);
+  auto default_variant = GetDefaultEngineVariant(ne);
+
+  if (default_variant.has_error()) {
+    // if we don't have a default variant, just stop
+    CTL_INF("No default variant found for " << ne << ". Exit update engine");
+    return cpp::fail(default_variant.error());
+  }
+  CTL_INF("Default variant: " << default_variant->variant
+                              << ", version: " + default_variant->version);
+
+  auto latest_version = GetLatestEngineVersion(ne);
+  if (latest_version.has_error()) {
+    // if can't get latest version, stop
+    CTL_INF("Can't get latest version for "
+            << ne << " error: " << latest_version.error());
+    return cpp::fail("Failed to get latest version: " + latest_version.error());
+  }
+  CTL_INF("Latest version: " + latest_version.value().name);
+
+  // check if local engines variants if latest version already exist
+  auto installed_variants = GetInstalledEngineVariants(ne);
+
+  bool is_installed = false;
+  for (const auto& v : installed_variants) {
+    CTL_INF("Installed version: " + v.version);
+    if (default_variant->variant == v.name &&
+        v.version == latest_version.value().name) {
+      is_installed = true;
+      break;
+    }
+  }
+
+  if (is_installed) {
+    CTL_INF("Engine " + ne + ", " + default_variant->variant +
+            " is already up-to-date! Version " +
+            latest_version.value().tag_name);
+    return cpp::fail("Engine " + ne + ", " + default_variant->variant +
+                     " is already up-to-date! Version " +
+                     latest_version.value().tag_name);
+  }
+
+  CTL_INF("Engine variant "
+          << default_variant->variant << " is not up-to-date! Current: "
+          << default_variant->version << ", latest: " << latest_version->name);
+
+  auto res = InstallEngineAsyncV2(engine, latest_version->tag_name,
+                                  default_variant->variant);
+
+  return EngineUpdateResult{.engine = engine,
+                            .variant = default_variant->variant,
+                            .from = default_variant->version,
+                            .to = latest_version->name};
 }

engine/services/engine_service.h

@@ -44,6 +44,22 @@ struct EngineVariantResponse {
   }
 };
 
+struct EngineUpdateResult {
+  std::string engine;
+  std::string variant;
+  std::string from;
+  std::string to;
+
+  Json::Value ToJson() const {
+    Json::Value root;
+    root["engine"] = engine;
+    root["variant"] = variant;
+    root["from"] = from;
+    root["to"] = to;
+    return root;
+  }
+};
+
 namespace system_info_utils {
 struct SystemInfo;
 }
@@ -116,8 +132,8 @@ class EngineService {
   cpp::result<DefaultEngineVariant, std::string> GetDefaultEngineVariant(
       const std::string& engine);
 
-  cpp::result<std::vector<EngineVariantResponse>, std::string>
-  GetInstalledEngineVariants(const std::string& engine) const;
+  std::vector<EngineVariantResponse> GetInstalledEngineVariants(
+      const std::string& engine) const;
 
   bool IsEngineLoaded(const std::string& engine) const;
 
@@ -137,6 +153,9 @@ class EngineService {
                                              const std::string& version,
                                              const std::string& path);
 
+  cpp::result<EngineUpdateResult, std::string> UpdateEngine(
+      const std::string& engine);
+
  private:
   cpp::result<bool, std::string> DownloadEngine(
       const std::string& engine, const std::string& version = "latest",
@@ -156,7 +175,6 @@ class EngineService {
       const std::string& engine, const std::string& version,
       const std::string& variant);
 
- private:
   std::shared_ptr<DownloadService> download_service_;
 
   struct HardwareInfo {