chore: cleanup

sangjanai · sangjanai · commit 0968abef3288 · 2025-03-17T14:50:23.000+07:00
diff --git a/docs/docs/engines/engine-extension.mdx b/docs/docs/engines/engine-extension.mdx
@@ -71,9 +71,6 @@ class EngineI {
       std::shared_ptr<Json::Value> json_body,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
 
-  // Compatibility and model management
-  virtual bool IsSupported(const std::string& f) = 0;
-
   virtual void GetModels(
       std::shared_ptr<Json::Value> jsonBody,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
diff --git a/engine/common/base.h b/engine/common/base.h
@@ -20,9 +20,6 @@ class BaseModel {
   virtual void GetModels(
       const HttpRequestPtr& req,
       std::function<void(const HttpResponsePtr&)>&& callback) = 0;
-  virtual void FineTuning(
-      const HttpRequestPtr& req,
-      std::function<void(const HttpResponsePtr&)>&& callback) = 0;
 };
 
 class BaseChatCompletion {
diff --git a/engine/controllers/server.cc b/engine/controllers/server.cc
@@ -121,17 +121,6 @@ void server::GetModels(const HttpRequestPtr& req,
   LOG_TRACE << "Done get models";
 }
 
-void server::FineTuning(
-    const HttpRequestPtr& req,
-    std::function<void(const HttpResponsePtr&)>&& callback) {
-  auto ir = inference_svc_->FineTuning(req->getJsonObject());
-  auto resp = cortex_utils::CreateCortexHttpJsonResponse(std::get<1>(ir));
-  resp->setStatusCode(
-      static_cast<HttpStatusCode>(std::get<0>(ir)["status_code"].asInt()));
-  callback(resp);
-  LOG_TRACE << "Done fine-tuning";
-}
-
 void server::Inference(const HttpRequestPtr& req,
                        std::function<void(const HttpResponsePtr&)>&& callback) {
 
diff --git a/engine/controllers/server.h b/engine/controllers/server.h
@@ -39,12 +39,8 @@ class server : public drogon::HttpController<server, false>,
   METHOD_ADD(server::ModelStatus, "modelstatus", Options, Post);
   METHOD_ADD(server::GetModels, "models", Get);
 
-  // cortex.python API
-  METHOD_ADD(server::FineTuning, "finetuning", Options, Post);
-
   // Openai compatible path
   ADD_METHOD_TO(server::ChatCompletion, "/v1/chat/completions", Options, Post);
-  ADD_METHOD_TO(server::FineTuning, "/v1/fine_tuning/job", Options, Post);
   ADD_METHOD_TO(server::Embedding, "/v1/embeddings", Options, Post);
   ADD_METHOD_TO(server::Inference, "/v1/inference", Options, Post);
   ADD_METHOD_TO(server::RouteRequest, "/v1/route/request", Options, Post);
@@ -69,9 +65,6 @@ class server : public drogon::HttpController<server, false>,
   void GetModels(
       const HttpRequestPtr& req,
       std::function<void(const HttpResponsePtr&)>&& callback) override;
-  void FineTuning(
-      const HttpRequestPtr& req,
-      std::function<void(const HttpResponsePtr&)>&& callback) override;
   void Inference(const HttpRequestPtr& req,
                  std::function<void(const HttpResponsePtr&)>&& callback);
   void RouteRequest(const HttpRequestPtr& req,
diff --git a/engine/cortex-common/EngineI.h b/engine/cortex-common/EngineI.h
@@ -47,9 +47,6 @@ class EngineI {
       std::shared_ptr<Json::Value> json_body,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
 
-  // For backward compatible checking
-  virtual bool IsSupported(const std::string& f) = 0;
-
   // Get list of running models
   virtual void GetModels(
       std::shared_ptr<Json::Value> jsonBody,
@@ -62,7 +59,6 @@ class EngineI {
   // Stop inflight chat completion in stream mode
   virtual void StopInferencing(const std::string& model_id) = 0;
 
-  virtual Json::Value GetRemoteModels() = 0;
   virtual void HandleRouteRequest(
       std::shared_ptr<Json::Value> json_body,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
diff --git a/engine/cortex-common/cortexpythoni.h b/engine/cortex-common/cortexpythoni.h
diff --git a/engine/cortex-common/local_enginei.h b/engine/cortex-common/local_enginei.h
diff --git a/engine/extensions/local-engine/local_engine.h b/engine/extensions/local-engine/local_engine.h
@@ -4,7 +4,7 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
-#include "cortex-common/local_enginei.h"
+#include "cortex-common/EngineI.h"
 #include "json/json.h"
 #include "services/engine_service.h"
 #include "utils/process/utils.h"
@@ -16,11 +16,16 @@ struct ServerAddress {
   int port;
   cortex::process::ProcessInfo process_info;
 };
-class LocalEngine : public LocalEngineI {
+class LocalEngine : public EngineI {
  public:
   LocalEngine(EngineService& engine_service, TaskQueue& q)
       : engine_service_(engine_service), q_(q) {}
   ~LocalEngine();
+
+  void Load(EngineLoadOption opts) final {}
+
+  void Unload(EngineUnloadOption opts) final {}
+
   void HandleChatCompletion(
       std::shared_ptr<Json::Value> json_body,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) final;
@@ -42,6 +47,22 @@ class LocalEngine : public LocalEngineI {
       std::shared_ptr<Json::Value> jsonBody,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) final;
 
+  bool SetFileLogger(int max_log_lines, const std::string& log_path) final {
+    return true;
+  }
+  void SetLogLevel(trantor::Logger::LogLevel logLevel) final {}
+
+  // Stop inflight chat completion in stream mode
+  void StopInferencing(const std::string& model_id) final {}
+
+  void HandleRouteRequest(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) final {}
+
+  void HandleInference(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) final {}
+
  private:
   std::unordered_map<std::string, ServerAddress> server_map_;
   EngineService& engine_service_;
diff --git a/engine/extensions/python-engine/python_engine.cc b/engine/extensions/python-engine/python_engine.cc
@@ -622,10 +622,6 @@ void PythonEngine::HandleInference(
   }
 }
 
-Json::Value PythonEngine::GetRemoteModels() {
-  return Json::Value();
-}
-
 void PythonEngine::StopInferencing(const std::string& model_id) {
   (void)model_id;
 }
@@ -860,15 +856,6 @@ void PythonEngine::HandleEmbedding(
   callback(Json::Value(), Json::Value());
 }
 
-bool PythonEngine::IsSupported(const std::string& f) {
-  if (f == "HandleChatCompletion" || f == "LoadModel" || f == "UnloadModel" ||
-      f == "GetModelStatus" || f == "GetModels" || f == "SetFileLogger" ||
-      f == "SetLogLevel") {
-    return true;
-  }
-  return false;
-}
-
 bool PythonEngine::SetFileLogger(int max_log_lines,
                                  const std::string& log_path) {
   if (!async_file_logger_) {
diff --git a/engine/extensions/python-engine/python_engine.h b/engine/extensions/python-engine/python_engine.h
@@ -95,7 +95,6 @@ class PythonEngine : public EngineI {
   void HandleEmbedding(
       std::shared_ptr<Json::Value> json_body,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) override;
-  bool IsSupported(const std::string& feature) override;
   bool SetFileLogger(int max_log_lines, const std::string& log_path) override;
   void SetLogLevel(trantor::Logger::LogLevel logLevel) override;
   void HandleRouteRequest(
@@ -104,7 +103,6 @@ class PythonEngine : public EngineI {
   void HandleInference(
       std::shared_ptr<Json::Value> json_body,
       std::function<void(Json::Value&&, Json::Value&&)>&& callback) override;
-  Json::Value GetRemoteModels() override;
   void StopInferencing(const std::string& model_id) override;
 };
 }  // namespace python_engine
diff --git a/engine/services/engine_service.cc b/engine/services/engine_service.cc
@@ -770,83 +770,16 @@ cpp::result<void, std::string> EngineService::LoadEngine(
   }
   if (engines_.find(ne) == engines_.end()) {
     CTL_INF("Loading local engine: " << engine_name);
+#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)
+    CTL_INF("CPU Info: " << cortex::cpuid::CpuInfo().to_string());
+#endif
     engines_[ne].engine = new cortex::local::LocalEngine(*this, *(q_.get()));
     CTL_INF("Loaded engine: " << engine_name);
   } else {
     CTL_INF("Engine has already been loaded: " << engine_name);
   }
 
   return {};
-
-  // End hard code
-
-  CTL_INF("Loading engine: " << ne);
-#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)
-  CTL_INF("CPU Info: " << cortex::cpuid::CpuInfo().to_string());
-#endif
-
-  auto engine_dir_path_res = GetEngineDirPath(ne);
-  if (engine_dir_path_res.has_error()) {
-    return cpp::fail(engine_dir_path_res.error());
-  }
-  auto engine_dir_path = engine_dir_path_res.value().first;
-  auto custom_engine_path = engine_dir_path_res.value().second;
-
-  try {
-    auto cuda_path = file_manager_utils::GetCudaToolkitPath(ne);
-
-#if defined(_WIN32) || defined(_WIN64)
-    // register deps
-    if (!(getenv("ENGINE_PATH"))) {
-      std::vector<std::filesystem::path> paths{};
-      paths.push_back(cuda_path);
-      paths.push_back(engine_dir_path);
-
-      CTL_DBG("Registering dylib for "
-              << ne << " with " << std::to_string(paths.size()) << " paths.");
-      for (const auto& path : paths) {
-        CTL_DBG("Registering path: " << path.string());
-      }
-
-      auto reg_result = dylib_path_manager_->RegisterPath(ne, paths);
-      if (reg_result.has_error()) {
-        CTL_DBG("Failed register lib paths for: " << ne);
-      } else {
-        CTL_DBG("Registered lib paths for: " << ne);
-      }
-    }
-#endif
-
-    auto dylib =
-        std::make_unique<cortex_cpp::dylib>(engine_dir_path.string(), "engine");
-
-    auto config = file_manager_utils::GetCortexConfig();
-    auto log_path = std::filesystem::path(config.logFolderPath) /
-                    std::filesystem::path(config.logLlamaCppPath);
-
-    // init
-    auto func = dylib->get_function<EngineI*()>("get_engine");
-    auto engine_obj = func();
-    auto load_opts = EngineI::EngineLoadOption{
-        .engine_path = engine_dir_path,
-        .deps_path = cuda_path,
-        .is_custom_engine_path = custom_engine_path,
-        .log_path = log_path,
-        .max_log_lines = config.maxLogLines,
-        .log_level = logging_utils_helper::global_log_level,
-    };
-    engine_obj->Load(load_opts);
-
-    engines_[ne].engine = engine_obj;
-    engines_[ne].dl = std::move(dylib);
-
-    CTL_DBG("Engine loaded: " << ne);
-    return {};
-  } catch (const cortex_cpp::dylib::load_error& e) {
-    CTL_ERR("Could not load engine: " << e.what());
-    engines_.erase(ne);
-    return cpp::fail("Could not load engine " + ne + ": " + e.what());
-  }
 }
 
 void EngineService::RegisterEngineLibPath() {
@@ -952,8 +885,6 @@ cpp::result<void, std::string> EngineService::UnloadEngine(
     auto unload_opts = EngineI::EngineUnloadOption{};
     e->Unload(unload_opts);
     delete e;
-  } else if (std::holds_alternative<LocalEngineI*>(engines_[ne].engine)) {
-    delete std::get<LocalEngineI*>(engines_[ne].engine);
   } else {
     delete std::get<RemoteEngineI*>(engines_[ne].engine);
   }
diff --git a/engine/services/engine_service.h b/engine/services/engine_service.h
@@ -9,8 +9,6 @@
 
 #include "common/engine_servicei.h"
 #include "cortex-common/EngineI.h"
-#include "cortex-common/cortexpythoni.h"
-#include "cortex-common/local_enginei.h"
 #include "cortex-common/remote_enginei.h"
 #include "database/engines.h"
 #include "services/database_service.h"
@@ -40,7 +38,7 @@ struct EngineUpdateResult {
 };
 
 using EngineV =
-    std::variant<EngineI*, CortexPythonEngineI*, RemoteEngineI*, LocalEngineI*>;
+    std::variant<EngineI*, RemoteEngineI*>;
 
 class EngineService : public EngineServiceI {
  private:
diff --git a/engine/services/inference_service.cc b/engine/services/inference_service.cc
diff --git a/engine/services/inference_service.h b/engine/services/inference_service.h

Original file line number	Diff line number	Diff line change
`@@ -622,10 +622,6 @@ void PythonEngine::HandleInference(`
`622`	`622`	`}`
`623`	`623`	`}`
`624`	`624`
`625`		`-Json::Value PythonEngine::GetRemoteModels() {`
`626`		`- return Json::Value();`
`627`		`-}`
`628`		`-`
`629`	`625`	`void PythonEngine::StopInferencing(const std::string& model_id) {`
`630`	`626`	`(void)model_id;`
`631`	`627`	`}`
`@@ -860,15 +856,6 @@ void PythonEngine::HandleEmbedding(`
`860`	`856`	`callback(Json::Value(), Json::Value());`
`861`	`857`	`}`
`862`	`858`
`863`		`-bool PythonEngine::IsSupported(const std::string& f) {`
`864`		`- if (f == "HandleChatCompletion" \|\| f == "LoadModel" \|\| f == "UnloadModel" \|\|`
`865`		`- f == "GetModelStatus" \|\| f == "GetModels" \|\| f == "SetFileLogger" \|\|`
`866`		`- f == "SetLogLevel") {`
`867`		`- return true;`
`868`		`- }`
`869`		`- return false;`
`870`		`-}`
`871`		`-`
`872`	`859`	`bool PythonEngine::SetFileLogger(int max_log_lines,`
`873`	`860`	`const std::string& log_path) {`
`874`	`861`	`if (!async_file_logger_) {`