update

namchuai · namchuai · commit 1262a4123b0f · 2024-10-03T13:28:13.000+07:00
diff --git a/engine/commands/chat_completion_cmd.cc b/engine/commands/chat_completion_cmd.cc
@@ -1,14 +1,11 @@
 #include "chat_completion_cmd.h"
-#include "httplib.h"
-
+#include "config/yaml_config.h"
 #include "cortex_upd_cmd.h"
 #include "database/models.h"
+#include "httplib.h"
 #include "model_status_cmd.h"
-#include "run_cmd.h"
 #include "server_start_cmd.h"
-#include "trantor/utils/Logger.h"
 #include "utils/logging_utils.h"
-#include "config/yaml_config.h"
 
 namespace commands {
 namespace {
@@ -73,7 +70,8 @@ void ChatCompletionCmd::Exec(const std::string& host, int port,
 
   // Only check if llamacpp engine
   if ((mc.engine.find("llamacpp") != std::string::npos) &&
-      !commands::ModelStatusCmd().IsLoaded(host, port, model_handle)) {
+      !commands::ModelStatusCmd(model_service_)
+           .IsLoaded(host, port, model_handle)) {
     CLI_LOG("Model is not loaded yet!");
     return;
   }
@@ -144,4 +142,4 @@ void ChatCompletionCmd::Exec(const std::string& host, int port,
   }
 }
 
-};  // namespace commands
+};  // namespace commands
diff --git a/engine/commands/chat_completion_cmd.h b/engine/commands/chat_completion_cmd.h
@@ -3,16 +3,21 @@
 #include <vector>
 #include "config/model_config.h"
 #include "nlohmann/json.hpp"
+#include "services/model_service.h"
 
 namespace commands {
 class ChatCompletionCmd {
  public:
+  explicit ChatCompletionCmd(const ModelService& model_service)
+      : model_service_{model_service} {};
+
   void Exec(const std::string& host, int port, const std::string& model_handle,
             std::string msg);
   void Exec(const std::string& host, int port, const std::string& model_handle,
             const config::ModelConfig& mc, std::string msg);
 
  private:
   std::vector<nlohmann::json> histories_;
+  ModelService model_service_;
 };
-}  // namespace commands
+}  // namespace commands
diff --git a/engine/commands/model_start_cmd.cc b/engine/commands/model_start_cmd.cc
@@ -1,25 +1,16 @@
 #include "model_start_cmd.h"
-#include "cortex_upd_cmd.h"
-#include "database/models.h"
-#include "httplib.h"
-#include "model_status_cmd.h"
-#include "nlohmann/json.hpp"
-#include "server_start_cmd.h"
-#include "services/model_service.h"
-#include "trantor/utils/Logger.h"
-#include "utils/file_manager_utils.h"
 #include "utils/logging_utils.h"
 
 namespace commands {
 bool ModelStartCmd::Exec(const std::string& host, int port,
                          const std::string& model_handle) {
-  ModelService ms;
-  auto res = ms.StartModel(host, port, model_handle);
+  auto res = model_service_.StartModel(host, port, model_handle);
 
   if (res.has_error()) {
     CLI_LOG("Error: " + res.error());
     return false;
   }
+
   CLI_LOG("Model loaded!");
   return true;
 }
diff --git a/engine/commands/model_start_cmd.h b/engine/commands/model_start_cmd.h
@@ -1,11 +1,17 @@
 #pragma once
 #include <string>
+#include "services/model_service.h"
 
 namespace commands {
 
 class ModelStartCmd {
  public:
+  explicit ModelStartCmd(const ModelService& model_service)
+      : model_service_{model_service} {};
+
   bool Exec(const std::string& host, int port, const std::string& model_handle);
 
+ private:
+  ModelService model_service_;
 };
 }  // namespace commands
diff --git a/engine/commands/model_status_cmd.cc b/engine/commands/model_status_cmd.cc
@@ -1,21 +1,15 @@
 #include "model_status_cmd.h"
-#include "config/yaml_config.h"
-#include "database/models.h"
-#include "httplib.h"
-#include "nlohmann/json.hpp"
 #include "utils/logging_utils.h"
-#include "services/model_service.h"
 
 namespace commands {
 bool ModelStatusCmd::IsLoaded(const std::string& host, int port,
                               const std::string& model_handle) {
-  ModelService ms;
-  auto res = ms.GetModelStatus(host, port, model_handle);
+  auto res = model_service_.GetModelStatus(host, port, model_handle);
 
   if (res.has_error()) {
-    // CLI_LOG("Error: " + res.error());
+    CTL_ERR("Error: " + res.error());
     return false;
   }
   return true;
 }
-}  // namespace commands
+}  // namespace commands
diff --git a/engine/commands/model_status_cmd.h b/engine/commands/model_status_cmd.h
@@ -1,11 +1,18 @@
 #pragma once
 #include <string>
+#include "services/model_service.h"
 
 namespace commands {
 
 class ModelStatusCmd {
  public:
+  explicit ModelStatusCmd(const ModelService& model_service)
+      : model_service_{model_service} {};
+
   bool IsLoaded(const std::string& host, int port,
                 const std::string& model_handle);
+
+ private:
+  ModelService model_service_;
 };
-}  // namespace commands
+}  // namespace commands
diff --git a/engine/commands/model_stop_cmd.cc b/engine/commands/model_stop_cmd.cc
@@ -1,18 +1,11 @@
 #include "model_stop_cmd.h"
-#include "config/yaml_config.h"
-#include "database/models.h"
-#include "httplib.h"
-#include "nlohmann/json.hpp"
-#include "utils/file_manager_utils.h"
 #include "utils/logging_utils.h"
-#include "services/model_service.h"
 
 namespace commands {
 
 void ModelStopCmd::Exec(const std::string& host, int port,
                         const std::string& model_handle) {
-  ModelService ms;
-  auto res = ms.StopModel(host, port, model_handle);
+  auto res = model_service_.StopModel(host, port, model_handle);
 
   if (res.has_error()) {
     CLI_LOG("Error: " + res.error());
diff --git a/engine/commands/model_stop_cmd.h b/engine/commands/model_stop_cmd.h
@@ -1,12 +1,18 @@
 #pragma once
 
 #include <string>
-#include "config/model_config.h"
+#include "services/model_service.h"
 
 namespace commands {
 
 class ModelStopCmd {
  public:
+  explicit ModelStopCmd(const ModelService& model_service)
+      : model_service_{model_service} {};
+
   void Exec(const std::string& host, int port, const std::string& model_handle);
+
+ private:
+  ModelService model_service_;
 };
 }  // namespace commands
diff --git a/engine/commands/run_cmd.cc b/engine/commands/run_cmd.cc
@@ -2,7 +2,6 @@
 #include "chat_completion_cmd.h"
 #include "config/yaml_config.h"
 #include "database/models.h"
-#include "model_start_cmd.h"
 #include "model_status_cmd.h"
 #include "server_start_cmd.h"
 #include "utils/logging_utils.h"
@@ -72,16 +71,24 @@ void RunCmd::Exec(bool chat_flag) {
     // If it is llamacpp, then check model status first
     {
       if ((mc.engine.find("llamacpp") == std::string::npos) ||
-          !commands::ModelStatusCmd().IsLoaded(host_, port_, *model_id)) {
-        if (!ModelStartCmd().Exec(host_, port_, *model_id)) {
+          !commands::ModelStatusCmd(model_service_)
+               .IsLoaded(host_, port_, *model_id)) {
+
+        auto result = model_service_.StartModel(host_, port_, *model_id);
+        if (result.has_error()) {
+          CLI_LOG("Error: " + result.error());
+          return;
+        }
+        if (!result.value()) {
+          CLI_LOG("Error: Failed to start model");
           return;
         }
       }
     }
 
     // Chat
     if (chat_flag) {
-      ChatCompletionCmd().Exec(host_, port_, *model_id, mc, "");
+      ChatCompletionCmd(model_service_).Exec(host_, port_, *model_id, mc, "");
     } else {
       CLI_LOG(*model_id << " model started successfully. Use `"
                         << commands::GetCortexBinary() << " chat " << *model_id
diff --git a/engine/controllers/command_line_parser.cc b/engine/controllers/command_line_parser.cc
@@ -20,7 +20,6 @@
 #include "commands/run_cmd.h"
 #include "commands/server_start_cmd.h"
 #include "commands/server_stop_cmd.h"
-#include "config/yaml_config.h"
 #include "services/engine_service.h"
 #include "utils/file_manager_utils.h"
 #include "utils/logging_utils.h"
@@ -35,6 +34,7 @@ constexpr const auto kSubcommands = "Subcommands";
 }  // namespace
 CommandLineParser::CommandLineParser()
     : app_("Cortex.cpp CLI"),
+      model_service_{ModelService(std::make_shared<DownloadService>())},
       engine_service_{EngineService(std::make_shared<DownloadService>())} {}
 
 bool CommandLineParser::SetupCommand(int argc, char** argv) {
@@ -152,7 +152,7 @@ void CommandLineParser::SetupCommonCommands() {
   chat_cmd->add_option("model_id", cml_data_.model_id, "");
   chat_cmd->add_option("-m,--message", cml_data_.msg,
                        "Message to chat with model");
-  chat_cmd->callback([this, chat_cmd] {
+  chat_cmd->callback([&, chat_cmd] {
     if (cml_data_.model_id.empty()) {
       CLI_LOG("[model_id] is required\n");
       CLI_LOG(chat_cmd->help());
@@ -164,10 +164,10 @@ void CommandLineParser::SetupCommonCommands() {
                                std::stoi(cml_data_.config.apiServerPort),
                                cml_data_.model_id);
     } else {
-      commands::ChatCompletionCmd().Exec(
-          cml_data_.config.apiServerHost,
-          std::stoi(cml_data_.config.apiServerPort), cml_data_.model_id,
-          cml_data_.msg);
+      commands::ChatCompletionCmd(model_service_)
+          .Exec(cml_data_.config.apiServerHost,
+                std::stoi(cml_data_.config.apiServerPort), cml_data_.model_id,
+                cml_data_.msg);
     }
   });
 }
@@ -198,15 +198,15 @@ void CommandLineParser::SetupModelCommands() {
                          " models start [model_id]");
   model_start_cmd->add_option("model_id", cml_data_.model_id, "");
   model_start_cmd->group(kSubcommands);
-  model_start_cmd->callback([this, model_start_cmd]() {
+  model_start_cmd->callback([&, model_start_cmd]() {
     if (cml_data_.model_id.empty()) {
       CLI_LOG("[model_id] is required\n");
       CLI_LOG(model_start_cmd->help());
       return;
     };
-    commands::ModelStartCmd().Exec(cml_data_.config.apiServerHost,
-                                   std::stoi(cml_data_.config.apiServerPort),
-                                   cml_data_.model_id);
+    commands::ModelStartCmd(model_service_)
+        .Exec(cml_data_.config.apiServerHost,
+              std::stoi(cml_data_.config.apiServerPort), cml_data_.model_id);
   });
 
   auto stop_model_cmd =
@@ -215,15 +215,15 @@ void CommandLineParser::SetupModelCommands() {
                         " models stop [model_id]");
   stop_model_cmd->group(kSubcommands);
   stop_model_cmd->add_option("model_id", cml_data_.model_id, "");
-  stop_model_cmd->callback([this, stop_model_cmd]() {
+  stop_model_cmd->callback([&, stop_model_cmd]() {
     if (cml_data_.model_id.empty()) {
       CLI_LOG("[model_id] is required\n");
       CLI_LOG(stop_model_cmd->help());
       return;
     };
-    commands::ModelStopCmd().Exec(cml_data_.config.apiServerHost,
-                                  std::stoi(cml_data_.config.apiServerPort),
-                                  cml_data_.model_id);
+    commands::ModelStopCmd(model_service_)
+        .Exec(cml_data_.config.apiServerHost,
+              std::stoi(cml_data_.config.apiServerPort), cml_data_.model_id);
   });
 
   auto list_models_cmd =
diff --git a/engine/controllers/command_line_parser.h b/engine/controllers/command_line_parser.h
@@ -2,6 +2,7 @@
 
 #include "CLI/CLI.hpp"
 #include "services/engine_service.h"
+#include "services/model_service.h"
 #include "utils/config_yaml_utils.h"
 class CommandLineParser {
  public:
@@ -29,6 +30,8 @@ class CommandLineParser {
 
   CLI::App app_;
   EngineService engine_service_;
+  ModelService model_service_;
+
   struct CmlData {
     std::string model_id;
     std::string msg;
diff --git a/engine/controllers/models.cc b/engine/controllers/models.cc
@@ -296,13 +296,13 @@ void Models::SetModelAlias(
     if (result.has_error()) {
       std::string message = result.error();
       LOG_ERROR << message;
-        Json::Value ret;
-        ret["result"] = "Set alias failed!";
-        ret["modelHandle"] = model_handle;
-        ret["message"] = message;
-        auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
-        resp->setStatusCode(k400BadRequest);
-        callback(resp);
+      Json::Value ret;
+      ret["result"] = "Set alias failed!";
+      ret["modelHandle"] = model_handle;
+      ret["message"] = message;
+      auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+      resp->setStatusCode(k400BadRequest);
+      callback(resp);
     } else {
       if (result.value()) {
         std::string message = "Successfully set model alias '" + model_alias +
@@ -350,7 +350,7 @@ void Models::StartModel(
     return;
   auto config = file_manager_utils::GetCortexConfig();
   auto model_handle = (*(req->getJsonObject())).get("model", "").asString();
-  auto result = model_service_.StartModel(
+  auto result = model_service_->StartModel(
       config.apiServerHost, std::stoi(config.apiServerPort), model_handle);
   if (result.has_error()) {
     Json::Value ret;
@@ -373,7 +373,7 @@ void Models::StopModel(const HttpRequestPtr& req,
     return;
   auto config = file_manager_utils::GetCortexConfig();
   auto model_handle = (*(req->getJsonObject())).get("model", "").asString();
-  auto result = model_service_.StopModel(
+  auto result = model_service_->StopModel(
       config.apiServerHost, std::stoi(config.apiServerPort), model_handle);
   if (result.has_error()) {
     Json::Value ret;
@@ -388,4 +388,4 @@ void Models::StopModel(const HttpRequestPtr& req,
     resp->setStatusCode(k200OK);
     callback(resp);
   }
-}
+}
diff --git a/engine/services/download_service.cc b/engine/services/download_service.cc
@@ -72,7 +72,7 @@ cpp::result<bool, std::string> DownloadService::AddDownloadTask(
     if (result.has_error()) {
       dl_err_msg = result.error();
       break;
-    } else if(result) {
+    } else if (result) {
       has_task_done |= result.value();
     }
   }
@@ -193,7 +193,7 @@ cpp::result<bool, std::string> DownloadService::Download(
           mode = "ab";
           CLI_LOG("Resuming download..");
         } else {
-          CLI_LOG("Start over..");          
+          CLI_LOG("Start over..");
         }
       } else {
         CLI_LOG(download_item.localPath.filename().string()
diff --git a/engine/services/download_service.h b/engine/services/download_service.h
