update

namchuai · namchuai · commit a674b9ceda45 · 2024-11-08T01:12:46.000+07:00
diff --git a/engine/cli/command_line_parser.cc b/engine/cli/command_line_parser.cc
@@ -88,31 +88,28 @@ bool CommandLineParser::SetupCommand(int argc, char** argv) {
 
   // Check new update
 #ifdef CORTEX_CPP_VERSION
-  if (cml_data_.check_upd) {
-    if (strcmp(CORTEX_CPP_VERSION, "default_version") != 0) {
-      // TODO(sang) find a better way to handle
-      // This is an extremely ugly way to deal with connection
-      // hang when network down
-      std::atomic<bool> done = false;
-      std::thread t([&]() {
-        if (auto latest_version =
-                commands::CheckNewUpdate(commands::kTimeoutCheckUpdate);
-            latest_version.has_value() &&
-            *latest_version != CORTEX_CPP_VERSION) {
-          CLI_LOG("\nNew Cortex release available: "
-                  << CORTEX_CPP_VERSION << " -> " << *latest_version);
-          CLI_LOG("To update, run: " << commands::GetRole()
-                                     << commands::GetCortexBinary()
-                                     << " update");
-        }
-        done = true;
-      });
-      // Do not wait for http connection timeout
-      t.detach();
-      int retry = 10;
-      while (!done && retry--) {
-        std::this_thread::sleep_for(commands::kTimeoutCheckUpdate / 10);
+  if (cml_data_.check_upd &&
+      strcmp(CORTEX_CPP_VERSION, "default_version") != 0) {
+    // TODO(sang) find a better way to handle
+    // This is an extremely ugly way to deal with connection
+    // hang when network down
+    std::atomic<bool> done = false;
+    std::thread t([&]() {
+      if (auto latest_version =
+              commands::CheckNewUpdate(commands::kTimeoutCheckUpdate);
+          latest_version.has_value() && *latest_version != CORTEX_CPP_VERSION) {
+        CLI_LOG("\nNew Cortex release available: "
+                << CORTEX_CPP_VERSION << " -> " << *latest_version);
+        CLI_LOG("To update, run: " << commands::GetRole()
+                                   << commands::GetCortexBinary() << " update");
       }
+      done = true;
+    });
+    // Do not wait for http connection timeout
+    t.detach();
+    int retry = 10;
+    while (!done && retry--) {
+      std::this_thread::sleep_for(commands::kTimeoutCheckUpdate / 10);
     }
   }
 #endif
diff --git a/engine/cli/main.cc b/engine/cli/main.cc
@@ -102,21 +102,76 @@ int main(int argc, char* argv[]) {
   RemoveBinaryTempFileIfExists();
 
   std::thread t1([]() {
-    try {
+    // TODO: namh current we only check for llamacpp. Need to add support for other engine
+    auto should_check_for_latest_llamacpp_version = true;
+    auto now = std::chrono::system_clock::now();
+
+    // read the yaml to see the last time we check for update
+    auto config = file_manager_utils::GetCortexConfig();
+    if (config.checkedForLlamacppUpdateAt != 0) {
+      // if it passed a day, then we should check
+      auto last_check =
+          std::chrono::system_clock::time_point(
+              std::chrono::milliseconds(config.checkedForLlamacppUpdateAt)) +
+          std::chrono::hours(24);
+      should_check_for_latest_llamacpp_version = now > last_check;
+      CTL_DBG("should_check_for_latest_llamacpp_version: "
+              << should_check_for_latest_llamacpp_version);
+    }
 
-      auto get_latest_llamacpp_version = []() {
+    auto get_latest_version = []() -> cpp::result<std::string, std::string> {
+      try {
         auto res = github_release_utils::GetReleaseByVersion(
             "janhq", "cortex.llamacpp", "latest");
         if (res.has_error()) {
           CTL_ERR("Failed to get latest llama.cpp version: " << res.error());
-          return;
+          return cpp::fail("Failed to get latest llama.cpp version: " +
+                           res.error());
         }
         CTL_INF("Latest llamacpp version: " << res->tag_name);
-      };
+        return res->tag_name;
+      } catch (const std::exception& e) {
+        CTL_ERR("Failed to get latest llama.cpp version: " << e.what());
+        return cpp::fail("Failed to get latest llama.cpp version: " +
+                         std::string(e.what()));
+      }
+    };
+
+    if (should_check_for_latest_llamacpp_version) {
+      auto res = get_latest_version();
+      if (res.has_error()) {
+        CTL_ERR("Failed to get latest llama.cpp version: " << res.error());
+        return;
+      }
+
+      CTL_DBG("latest llama.cpp version: " << res.value());
+      config.checkedForLlamacppUpdateAt =
+          std::chrono::duration_cast<std::chrono::milliseconds>(
+              now.time_since_epoch())
+              .count();
+      config.latestLlamacppRelease = res.value();
+
+      auto upd_config_res = config_yaml_utils::DumpYamlConfig(
+          config, file_manager_utils::GetConfigurationPath().string());
+      if (upd_config_res.has_error()) {
+        CTL_ERR("Failed to update config file: " << upd_config_res.error());
+      } else {
+        CTL_INF("Updated config file with latest llama.cpp version: "
+                << res.value());
+      }
+    }
 
-      get_latest_llamacpp_version();
-    } catch (const std::exception& e) {
-      CTL_ERR("Failed to get latest llama.cpp version: " << e.what());
+    CTL_DBG("latest llama.cpp version: " << config.latestLlamacppRelease);
+    CTL_DBG("llamacpp version: " << config.llamacppVersion);
+    if (config.llamacppVersion.empty()) {
+      return;
+    }
+
+    if (config.latestLlamacppRelease != config.llamacppVersion) {
+      CLI_LOG(
+          "New llama.cpp version available: " << config.latestLlamacppRelease);
+      CLI_LOG("To update, run: " << commands::GetCortexBinary()
+                                 << " engines update llama-cpp");
     }
   });
   t1.detach();
diff --git a/engine/test/components/test_cortex_config.cc b/engine/test/components/test_cortex_config.cc
@@ -18,6 +18,7 @@ class CortexConfigTest : public ::testing::Test {
                       kDefaultHost,
                       kDefaultPort,
                       kDefaultCheckedForUpdateAt,
+                      kDefaultCheckedForLlamacppUpdateAt,
                       kDefaultLatestRelease};
   }
 
@@ -39,6 +40,7 @@ TEST_F(CortexConfigTest, DumpYamlConfig_WritesCorrectly) {
                          "localhost",
                          "8080",
                          123456789,
+                         123456789,
                          "v1.0.0"};
 
   auto result = DumpYamlConfig(config, test_file_path);
@@ -67,6 +69,7 @@ TEST_F(CortexConfigTest, FromYaml_ReadsCorrectly) {
                          "localhost",
                          "8080",
                          123456789,
+                         123456789,
                          "v1.0.0"};
 
   auto result = DumpYamlConfig(config, test_file_path);
diff --git a/engine/utils/config_yaml_utils.h b/engine/utils/config_yaml_utils.h
@@ -19,8 +19,10 @@ struct CortexConfig {
   std::string apiServerHost;
   std::string apiServerPort;
   uint64_t checkedForUpdateAt;
+  uint64_t checkedForLlamacppUpdateAt;
   std::string latestRelease;
 
+  std::string latestLlamacppRelease;
   std::string huggingFaceToken;
   /**
    * Github's API requires a user-agent string.
@@ -38,7 +40,9 @@ const std::string kDefaultHost{"127.0.0.1"};
 const std::string kDefaultPort{"39281"};
 const int kDefaultMaxLines{100000};
 constexpr const uint64_t kDefaultCheckedForUpdateAt = 0u;
+constexpr const uint64_t kDefaultCheckedForLlamacppUpdateAt = 0u;
 constexpr const auto kDefaultLatestRelease = "default_version";
+constexpr const auto kDefaultLatestLlamacppRelease = "";
 constexpr const auto kDefaultCorsEnabled = true;
 const std::vector<std::string> kDefaultEnabledOrigins{};
 
@@ -61,7 +65,9 @@ inline cpp::result<void, std::string> DumpYamlConfig(const CortexConfig& config,
     node["apiServerHost"] = config.apiServerHost;
     node["apiServerPort"] = config.apiServerPort;
     node["checkedForUpdateAt"] = config.checkedForUpdateAt;
+    node["checkedForLlamacppUpdateAt"] = config.checkedForLlamacppUpdateAt;
     node["latestRelease"] = config.latestRelease;
+    node["latestLlamacppRelease"] = config.latestLlamacppRelease;
     node["huggingFaceToken"] = config.huggingFaceToken;
     node["gitHubUserAgent"] = config.gitHubUserAgent;
     node["gitHubToken"] = config.gitHubToken;
@@ -92,7 +98,8 @@ inline CortexConfig FromYaml(const std::string& path,
         (!node["logFolderPath"] || !node["dataFolderPath"] ||
          !node["maxLogLines"] || !node["apiServerHost"] ||
          !node["apiServerPort"] || !node["checkedForUpdateAt"] ||
-         !node["latestRelease"] || !node["logLlamaCppPath"] ||
+         !node["checkedForLlamacppUpdateAt"] || !node["latestRelease"] ||
+         !node["latestLlamacppRelease"] || !node["logLlamaCppPath"] ||
          !node["logOnnxPath"] || !node["logTensorrtLLMPath"] ||
          !node["huggingFaceToken"] || !node["gitHubUserAgent"] ||
          !node["gitHubToken"] || !node["llamacppVariant"] ||
@@ -126,9 +133,17 @@ inline CortexConfig FromYaml(const std::string& path,
         .checkedForUpdateAt = node["checkedForUpdateAt"]
                                   ? node["checkedForUpdateAt"].as<uint64_t>()
                                   : default_cfg.checkedForUpdateAt,
+        .checkedForLlamacppUpdateAt =
+            node["checkedForLlamacppUpdateAt"]
+                ? node["checkedForLlamacppUpdateAt"].as<uint64_t>()
+                : default_cfg.checkedForLlamacppUpdateAt,
         .latestRelease = node["latestRelease"]
                              ? node["latestRelease"].as<std::string>()
                              : default_cfg.latestRelease,
+        .latestLlamacppRelease =
+            node["latestLlamacppRelease"]
+                ? node["latestLlamacppRelease"].as<std::string>()
+                : default_cfg.latestLlamacppRelease,
         .huggingFaceToken = node["huggingFaceToken"]
                                 ? node["huggingFaceToken"].as<std::string>()
                                 : "",
diff --git a/engine/utils/file_manager_utils.h b/engine/utils/file_manager_utils.h
@@ -195,7 +195,10 @@ inline config_yaml_utils::CortexConfig GetCortexConfig() {
       .apiServerHost = config_yaml_utils::kDefaultHost,
       .apiServerPort = config_yaml_utils::kDefaultPort,
       .checkedForUpdateAt = config_yaml_utils::kDefaultCheckedForUpdateAt,
+      .checkedForLlamacppUpdateAt =
+          config_yaml_utils::kDefaultCheckedForLlamacppUpdateAt,
       .latestRelease = config_yaml_utils::kDefaultLatestRelease,
+      .latestLlamacppRelease = config_yaml_utils::kDefaultLatestLlamacppRelease,
       .enableCors = config_yaml_utils::kDefaultCorsEnabled,
       .allowedOrigins = config_yaml_utils::kDefaultEnabledOrigins};
 
diff --git a/engine/utils/github_release_utils.h b/engine/utils/github_release_utils.h
@@ -4,6 +4,7 @@
 #include "utils/curl_utils.h"
 #include "utils/engine_constants.h"
 #include "utils/engine_matcher_utils.h"
+#include "utils/logging_utils.h"
 #include "utils/result.hpp"
 #include "utils/url_parser.h"
 
@@ -193,7 +194,7 @@ inline cpp::result<GitHubRelease, std::string> GetReleaseByVersion(
       .pathParams = path_params,
   };
 
-  CTL_INF("GetReleaseByVersion: " << url.ToFullPath());
+  CTL_DBG("GetReleaseByVersion: " << url.ToFullPath());
   auto result =
       curl_utils::SimpleGetJson(url_parser::FromUrl(url), kCurlGetTimeout);
 
