fix: emit error if engine is not ready

Author: namchuai

engine/cli/commands/engine_get_cmd.cc

@@ -1,8 +1,9 @@
 #include "engine_get_cmd.h"
+#include <json/reader.h>
+#include <json/value.h>
 #include <iostream>
 
 #include "httplib.h"
-#include "json/json.h"
 #include "server_start_cmd.h"
 #include "utils/logging_utils.h"
 
@@ -29,7 +30,6 @@ void EngineGetCmd::Exec(const std::string& host, int port,
   auto res = cli.Get("/v1/engines/" + engine_name);
   if (res) {
     if (res->status == httplib::StatusCode::OK_200) {
-      // CLI_LOG(res->body);
       Json::Value v;
       Json::Reader reader;
       reader.parse(res->body, v);
@@ -39,7 +39,8 @@ void EngineGetCmd::Exec(const std::string& host, int port,
                      v["status"].asString()});
 
     } else {
-      CLI_LOG_ERROR("Failed to get engine list with status code: " << res->status);
+      CLI_LOG_ERROR(
+          "Failed to get engine list with status code: " << res->status);
       return;
     }
   } else {

engine/controllers/models.cc

@@ -162,7 +162,6 @@ void Models::GetModel(const HttpRequestPtr& req,
     config::YamlHandler yaml_handler;
     auto model_entry = modellist_handler.GetModelInfo(model_id);
     if (model_entry.has_error()) {
-      // CLI_LOG("Error: " + model_entry.error());
       ret["id"] = model_id;
       ret["object"] = "model";
       ret["result"] = "Fail to get model information";
@@ -348,6 +347,34 @@ void Models::StartModel(
   auto model_handle = (*(req->getJsonObject())).get("model", "").asString();
   auto custom_prompt_template =
       (*(req->getJsonObject())).get("prompt_template", "").asString();
+  auto model_entry = model_service_->GetDownloadedModel(model_handle);
+  if (!model_entry.has_value()) {
+    Json::Value ret;
+    ret["message"] = "Cannot find model: " + model_handle;
+    auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+    resp->setStatusCode(drogon::k400BadRequest);
+    callback(resp);
+    return;
+  }
+  auto engine_name = model_entry.value().engine;
+  auto engine_entry = engine_service_->GetEngineInfo(engine_name);
+  if (engine_entry.has_error()) {
+    Json::Value ret;
+    ret["message"] = "Cannot find engine: " + engine_name;
+    auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+    resp->setStatusCode(drogon::k400BadRequest);
+    callback(resp);
+    return;
+  }
+  if (engine_entry->status != "Ready") {
+    Json::Value ret;
+    ret["message"] = "Engine is not ready! Please install first!";
+    auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+    resp->setStatusCode(drogon::k400BadRequest);
+    callback(resp);
+    return;
+  }
+
   auto result = model_service_->StartModel(
       config.apiServerHost, std::stoi(config.apiServerPort), model_handle,
       custom_prompt_template);

engine/controllers/models.h

@@ -2,6 +2,7 @@
 
 #include <drogon/HttpController.h>
 #include <trantor/utils/Logger.h>
+#include "services/engine_service.h"
 #include "services/model_service.h"
 
 using namespace drogon;
@@ -32,8 +33,9 @@ class Models : public drogon::HttpController<Models, false> {
   ADD_METHOD_TO(Models::GetModelStatus, "/v1/models/status/{1}", Get);
   METHOD_LIST_END
 
-  explicit Models(std::shared_ptr<ModelService> model_service)
-      : model_service_{model_service} {}
+  explicit Models(std::shared_ptr<ModelService> model_service,
+                  std::shared_ptr<EngineService> engine_service)
+      : model_service_{model_service}, engine_service_{engine_service} {}
 
   void PullModel(const HttpRequestPtr& req,
                  std::function<void(const HttpResponsePtr&)>&& callback);
@@ -69,4 +71,5 @@ class Models : public drogon::HttpController<Models, false> {
 
  private:
   std::shared_ptr<ModelService> model_service_;
+  std::shared_ptr<EngineService> engine_service_;
 };

engine/database/models.h

@@ -1,9 +1,9 @@
 #pragma once
 
+#include <SQLiteCpp/Database.h>
 #include <trantor/utils/Logger.h>
 #include <string>
 #include <vector>
-#include "SQLiteCpp/SQLiteCpp.h"
 #include "utils/result.hpp"
 
 namespace cortex::db {

engine/e2e-test/test_api_model_start.py

@@ -1,7 +1,6 @@
 import pytest
 import requests
-from test_runner import popen
-from test_runner import start_server, stop_server, run
+from test_runner import run, start_server, stop_server
 
 
 class TestApiModelStart:
@@ -14,14 +13,18 @@ def setup_and_teardown(self):
             raise Exception("Failed to start server")
         run("Install Engine", ["engines", "install", "llama-cpp"], timeout=None)
         run("Delete model", ["models", "delete", "tinyllama:gguf"])
-        run("Pull model", ["pull", "tinyllama:gguf"], timeout=None,)
+        run(
+            "Pull model",
+            ["pull", "tinyllama:gguf"],
+            timeout=None,
+        )
 
         yield
 
         # Teardown
         stop_server()
 
     def test_models_start_should_be_successful(self):
-        json_body = {'model': 'tinyllama:gguf'}
-        response = requests.post("http://localhost:3928/models/start", json = json_body)
+        json_body = {"model": "tinyllama:gguf"}
+        response = requests.post("http://localhost:3928/models/start", json=json_body)
         assert response.status_code == 200, f"status_code: {response.status_code}"

engine/e2e-test/test_api_model_stop.py

@@ -1,6 +1,6 @@
 import pytest
 import requests
-from test_runner import start_server, stop_server
+from test_runner import run, start_server, stop_server
 
 
 class TestApiModelStop:
@@ -12,14 +12,15 @@ def setup_and_teardown(self):
         if not success:
             raise Exception("Failed to start server")
 
+        run("Install Engine", ["engines", "install", "llama-cpp"], timeout=None)
         yield
 
         # Teardown
         stop_server()
 
     def test_models_stop_should_be_successful(self):
-        json_body = {'model': 'tinyllama:gguf'}
-        response = requests.post("http://localhost:3928/models/start", json = json_body)
+        json_body = {"model": "tinyllama:gguf"}
+        response = requests.post("http://localhost:3928/models/start", json=json_body)
         assert response.status_code == 200, f"status_code: {response.status_code}"
-        response = requests.post("http://localhost:3928/models/stop", json = json_body)
+        response = requests.post("http://localhost:3928/models/stop", json=json_body)
         assert response.status_code == 200, f"status_code: {response.status_code}"

engine/main.cc

@@ -95,7 +95,7 @@ void RunServer(std::optional<int> port) {
 
   // initialize custom controllers
   auto engine_ctl = std::make_shared<Engines>(engine_service);
-  auto model_ctl = std::make_shared<Models>(model_service);
+  auto model_ctl = std::make_shared<Models>(model_service, engine_service);
   auto event_ctl = std::make_shared<Events>(event_queue_ptr);
   auto pm_ctl = std::make_shared<ProcessManager>();
 

engine/services/model_service.cc

@@ -198,28 +198,28 @@ cpp::result<std::string, std::string> ModelService::HandleCortexsoModel(
 
 std::optional<config::ModelConfig> ModelService::GetDownloadedModel(
     const std::string& modelId) const {
-  auto models_path = file_manager_utils::GetModelsContainerPath();
-  if (!std::filesystem::exists(models_path) ||
-      !std::filesystem::is_directory(models_path)) {
+
+  cortex::db::Models modellist_handler;
+  config::YamlHandler yaml_handler;
+  auto model_entry = modellist_handler.GetModelInfo(modelId);
+  if (!model_entry.has_value()) {
     return std::nullopt;
   }
 
-  for (const auto& entry : std::filesystem::directory_iterator(models_path)) {
-    if (entry.is_regular_file() &&
-        entry.path().filename().string() == modelId &&
-        entry.path().extension() == ".yaml") {
-      try {
-        config::YamlHandler handler;
-        handler.ModelConfigFromFile(entry.path().string());
-        auto model_conf = handler.GetModelConfig();
-        return model_conf;
-      } catch (const std::exception& e) {
-        LOG_ERROR << "Error reading yaml file '" << entry.path().string()
-                  << "': " << e.what();
-      }
-    }
+  try {
+    config::YamlHandler yaml_handler;
+    namespace fs = std::filesystem;
+    namespace fmu = file_manager_utils;
+    yaml_handler.ModelConfigFromFile(
+        fmu::ToAbsoluteCortexDataPath(
+            fs::path(model_entry.value().path_to_model_yaml))
+            .string());
+    return yaml_handler.GetModelConfig();
+  } catch (const std::exception& e) {
+    LOG_ERROR << "Error reading yaml file '" << model_entry->path_to_model_yaml
+              << "': " << e.what();
+    return std::nullopt;
   }
-  return std::nullopt;
 }
 
 cpp::result<DownloadTask, std::string> ModelService::HandleDownloadUrlAsync(