feat: engine management

Author: namchuai

engine/cli/command_line_parser.cc

@@ -1,12 +1,13 @@
 #include "command_line_parser.h"
 #include <memory>
 #include <optional>
+#include <string>
 #include "commands/cortex_upd_cmd.h"
 #include "commands/engine_get_cmd.h"
 #include "commands/engine_install_cmd.h"
 #include "commands/engine_list_cmd.h"
+#include "commands/engine_release_cmd.h"
 #include "commands/engine_uninstall_cmd.h"
-#include "commands/model_alias_cmd.h"
 #include "commands/model_del_cmd.h"
 #include "commands/model_get_cmd.h"
 #include "commands/model_import_cmd.h"
@@ -268,30 +269,6 @@ void CommandLineParser::SetupModelCommands() {
                                  cml_data_.model_id);
   });
 
-  std::string model_alias;
-  auto model_alias_cmd =
-      models_cmd->add_subcommand("alias", "Add alias name for a modelID");
-  model_alias_cmd->usage("Usage:\n" + commands::GetCortexBinary() +
-                         " models alias --model_id [model_id] --alias [alias]");
-  model_alias_cmd->group(kSubcommands);
-  model_alias_cmd->add_option(
-      "--model_id", cml_data_.model_id,
-      "Can be modelID or model alias to identify model");
-  model_alias_cmd->add_option("--alias", cml_data_.model_alias,
-                              "new alias to be set");
-  model_alias_cmd->callback([this, model_alias_cmd]() {
-    if (std::exchange(executed_, true))
-      return;
-    if (cml_data_.model_id.empty() || cml_data_.model_alias.empty()) {
-      CLI_LOG("[model_id] and [alias] are required\n");
-      CLI_LOG(model_alias_cmd->help());
-      return;
-    }
-    commands::ModelAliasCmd mdc;
-    mdc.Exec(cml_data_.config.apiServerHost,
-             std::stoi(cml_data_.config.apiServerPort), cml_data_.model_id,
-             cml_data_.model_alias);
-  });
   // Model update parameters comment
   ModelUpdate(models_cmd);
 
@@ -346,6 +323,21 @@ void CommandLineParser::SetupEngineCommands() {
                  std::stoi(cml_data_.config.apiServerPort));
   });
 
+  auto installv2_cmd = engines_cmd->add_subcommand("release", "Install engine");
+  installv2_cmd->group(kSubcommands);
+  installv2_cmd->callback([this, installv2_cmd] {
+    if (std::exchange(executed_, true))
+      return;
+    if (installv2_cmd->get_subcommands().empty()) {
+      CLI_LOG("[engine_name] is required\n");
+      CLI_LOG(installv2_cmd->help());
+    }
+  });
+  for (auto& engine : engine_service_.kSupportEngines) {
+    std::string engine_name{engine};
+    EngineInstallV2(installv2_cmd, engine_name);
+  }
+
   auto install_cmd = engines_cmd->add_subcommand("install", "Install engine");
   install_cmd->usage("Usage:\n" + commands::GetCortexBinary() +
                      " engines install [engine_name] [options]");
@@ -444,6 +436,25 @@ void CommandLineParser::SetupSystemCommands() {
   });
 }
 
+void CommandLineParser::EngineInstallV2(CLI::App* parent,
+                                        const std::string& engine_name) {
+  auto install_engine_cmd = parent->add_subcommand(engine_name, "");
+  install_engine_cmd->usage("Usage:\n" + commands::GetCortexBinary() +
+                            " engines install " + engine_name + " [options]");
+  install_engine_cmd->group(kEngineGroup);
+  install_engine_cmd->callback([this, engine_name] {
+    if (std::exchange(executed_, true))
+      return;
+    auto result = commands::EngineReleaseCmd().Exec(
+        cml_data_.config.apiServerHost,
+        std::stoi(cml_data_.config.apiServerPort), engine_name);
+
+    if (result.has_error()) {
+      CLI_LOG(result.error());
+    }
+  });
+}
+
 void CommandLineParser::EngineInstall(CLI::App* parent,
                                       const std::string& engine_name,
                                       std::string& version, std::string& src) {

engine/cli/command_line_parser.h

@@ -22,6 +22,8 @@ class CommandLineParser {
 
   void SetupSystemCommands();
 
+  void EngineInstallV2(CLI::App* parent, const std::string& engine_name);
+
   void EngineInstall(CLI::App* parent, const std::string& engine_name,
                      std::string& version, std::string& src);
 

engine/cli/commands/engine_release_cmd.cc

@@ -0,0 +1,84 @@
+#include "engine_release_cmd.h"
+#include <vector>
+#include "commands/server_start_cmd.h"
+#include "utils/cli_selection_utils.h"
+#include "utils/curl_utils.h"
+#include "utils/github_release_utils.h"
+#include "utils/logging_utils.h"
+#include "utils/url_parser.h"
+
+namespace commands {
+
+cpp::result<void, std::string> EngineReleaseCmd::Exec(
+    const std::string& host, int port, const std::string& engine_name) {
+
+  // Start server if server is not started yet
+  if (!commands::IsServerAlive(host, port)) {
+    CLI_LOG("Starting server ...");
+    commands::ServerStartCmd ssc;
+    if (!ssc.Exec(host, port)) {
+      return cpp::fail("Failed to start server");
+    }
+  }
+
+  auto url_obj = url_parser::Url{
+      .protocol = "http",
+      .host = host + ":" + std::to_string(port),
+      .pathParams = {"v1", "engines", engine_name, "releases"},
+  };
+
+  auto res = curl_utils::SimpleGetJson(url_obj.ToFullPath());
+  if (res.has_error()) {
+    CLI_LOG("url: " + url_obj.ToFullPath());
+    return cpp::fail("Failed to get engine release: " + engine_name +
+                     ", error: " + res.error());
+  }
+  if (res.value().size() == 0) {
+    return cpp::fail("No release found for engine: " + engine_name);
+  }
+
+  std::vector<std::string> selections;
+  for (const auto& release : res.value()) {
+    selections.push_back(release["tag_name"].asString());
+  }
+
+  auto selection =
+      cli_selection_utils::PrintSelection(selections, "Available versions:");
+  if (!selection.has_value()) {
+    return cpp::fail("Invalid selection!");  // TODO: return latest version
+  }
+
+  CLI_LOG("Selected " + engine_name + " version " + selection.value());
+  Json::Value selected_release;
+  for (const auto& release : res.value()) {
+    if (release["tag_name"].asString() == selection.value()) {
+      selected_release = release;
+      break;
+    }
+  }
+
+  std::vector<std::string> variant_selections;
+  for (const auto& variant : selected_release["assets"]) {
+    variant_selections.push_back(variant["name"].asString());
+  }
+
+  auto variant_selection = cli_selection_utils::PrintSelection(
+      variant_selections, "Available variant:");
+  if (!variant_selection.has_value()) {
+    return cpp::fail("Invalid variant selection!");
+  }
+
+  CLI_LOG("Selected " + variant_selection.value());
+  github_release_utils::GitHubAsset selected_asset;
+  for (const auto& asset : selected_release["assets"]) {
+    if (asset["name"] == variant_selection) {
+      selected_asset = github_release_utils::GitHubAsset::FromJson(asset);
+      break;
+    }
+  }
+
+  // proceed to download
+
+  return {};
+}
+};  // namespace commands

engine/cli/commands/engine_release_cmd.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+#include "utils/result.hpp"
+
+namespace commands {
+class EngineReleaseCmd {
+ public:
+  cpp::result<void, std::string> Exec(const std::string& host, int port,
+                                      const std::string& engine_name);
+};
+
+}  // namespace commands

engine/cli/commands/model_alias_cmd.cc

@@ -1,7 +1,5 @@
 #include "model_start_cmd.h"
-#include "config/yaml_config.h"
 #include "cortex_upd_cmd.h"
-#include "database/models.h"
 #include "httplib.h"
 #include "run_cmd.h"
 #include "server_start_cmd.h"

engine/cli/commands/model_alias_cmd.h

@@ -104,21 +104,22 @@ void RunCmd::Exec(bool run_detach) {
 
     // Check if engine existed. If not, download it
     {
-      auto required_engine =
-          engine_service_.GetEngineInfo(Repo2Engine(mc.engine));
-
-      if (!required_engine.has_value()) {
-        throw std::runtime_error("Engine not found: " + mc.engine);
-      }
-      if (required_engine.value().status == EngineService::kIncompatible) {
-        throw std::runtime_error("Engine " + mc.engine + " is incompatible");
-      }
-      if (required_engine.value().status == EngineService::kNotInstalled) {
-        auto install_engine_result = engine_service_.InstallEngine(mc.engine);
-        if (install_engine_result.has_error()) {
-          throw std::runtime_error(install_engine_result.error());
-        }
-      }
+      // TODO: NamH need refactor this
+      // auto required_engine =
+      //     engine_service_.GetEngineInfo(Repo2Engine(mc.engine));
+      //
+      // if (!required_engine.has_value()) {
+      //   throw std::runtime_error("Engine not found: " + mc.engine);
+      // }
+      // if (required_engine.value().status == EngineService::kIncompatible) {
+      //   throw std::runtime_error("Engine " + mc.engine + " is incompatible");
+      // }
+      // if (required_engine.value().status == EngineService::kNotInstalled) {
+      //   auto install_engine_result = engine_service_.InstallEngine(mc.engine);
+      //   if (install_engine_result.has_error()) {
+      //     throw std::runtime_error(install_engine_result.error());
+      //   }
+      // }
     }
 
     // Start server if it is not running

engine/cli/commands/model_start_cmd.cc

@@ -5,6 +5,7 @@
 #include <nlohmann/json.hpp>
 #include <sstream>
 #include <string>
+#include <unordered_map>
 
 enum class DownloadType { Model, Engine, Miscellaneous, CudaToolkit, Cortex };
 
@@ -14,6 +15,8 @@ struct DownloadItem {
 
   std::string id;
 
+  std::optional<std::unordered_map<std::string, std::string>> headers;
+
   std::string downloadUrl;
 
   /**

engine/cli/commands/run_cmd.cc

@@ -2,9 +2,7 @@
 #include <cstdint>
 #include <cstring>
 #include <ctime>
-#include <fstream>
 #include <iostream>
-#include <map>
 #include <regex>
 #include <stdexcept>
 #include <string>
@@ -41,7 +39,6 @@ void GGUFHandler::OpenFile(const std::string& file_path) {
   if (file_handle_ == INVALID_HANDLE_VALUE) {
     throw std::runtime_error("Failed to open file");
   }
-
   // Get the file size
   LARGE_INTEGER file_size_struct;
   if (!GetFileSizeEx(file_handle_, &file_size_struct)) {