feat(cli): add service health and proxy deploy checks

Author: GaspardKirira

include/vix/cli/commands/deploy/DeployTypes.hpp

@@ -95,6 +95,16 @@ namespace vix::commands::deploy
      */
     bool healthPublic{false};
 
+    /**
+     * @brief Whether deploy should validate the Nginx reverse proxy config.
+     */
+    bool proxyCheck{false};
+
+    /**
+     * @brief Whether deploy should reload Nginx after validation.
+     */
+    bool proxyReload{false};
+
     /**
      * @brief Whether deploy should print recent service logs on failure.
      */

src/commands/DeployCommand.cpp

@@ -122,6 +122,8 @@ namespace vix::commands
         << "  production.deploy.service\n"
         << "  production.deploy.health_local\n"
         << "  production.deploy.health_public\n"
+        << "  production.deploy.proxy_check\n"
+        << "  production.deploy.proxy_reload\n"
         << "  production.deploy.logs_on_failure\n";
 
     return 0;

src/commands/ServiceCommand.cpp

@@ -12,6 +12,9 @@
  *
  */
 #include <vix/cli/commands/ServiceCommand.hpp>
+#include <vix/net/http/CurlClient.hpp>
+#include <vix/net/http/ClientRequest.hpp>
+#include <vix/net/http/Method.hpp>
 #include <vix/cli/util/Ui.hpp>
 #include <vix/utils/Env.hpp>
 
@@ -71,6 +74,43 @@ namespace vix::commands
       return s;
     }
 
+    struct HealthResult
+    {
+      bool ok{false};
+      int statusCode{0};
+      std::string error;
+    };
+
+    HealthResult run_http_health_check(
+        const std::string &url,
+        std::uint64_t timeoutMs)
+    {
+      HealthResult result;
+
+      vix::net::http::CurlClient client;
+
+      vix::net::http::ClientRequest request;
+      request.set_method(vix::net::http::Method::Get)
+          .set_url(url)
+          .set_timeout_ms(timeoutMs);
+
+      auto response = client.send(request);
+
+      if (!response)
+      {
+        result.error = std::string(response.error().message());
+        return result;
+      }
+
+      result.statusCode = response.value().status_code;
+      result.ok = response.value().success();
+
+      if (!response.value().error.empty())
+        result.error = response.value().error;
+
+      return result;
+    }
+
     std::string shell_quote(const std::string &s)
     {
       std::string out = "'";
@@ -282,8 +322,114 @@ namespace vix::commands
       int restartSec{3};
       int limitNoFile{65535};
       std::optional<fs::path> vixDir;
+      std::optional<std::string> healthLocal;
+      std::optional<std::string> healthPublic;
+      std::uint64_t healthTimeoutMs{2000};
     };
 
+    ServiceConfig load_service_config();
+
+    int service_health()
+    {
+      const ServiceConfig cfg = load_service_config();
+
+      vix::cli::util::section(std::cout, "Service Health");
+
+      vix::cli::util::kv(std::cout, "Service", cfg.serviceName);
+      vix::cli::util::kv(std::cout, "Timeout", std::to_string(cfg.healthTimeoutMs) + "ms");
+
+      bool ok = true;
+
+      if (cfg.healthLocal)
+      {
+        vix::cli::util::kv(std::cout, "Health local", *cfg.healthLocal);
+
+        const HealthResult result =
+            run_http_health_check(*cfg.healthLocal, cfg.healthTimeoutMs);
+
+        if (result.ok)
+        {
+          vix::cli::util::ok_line(
+              std::cout,
+              "local health check passed: HTTP " + std::to_string(result.statusCode));
+        }
+        else
+        {
+          ok = false;
+
+          vix::cli::util::err_line(
+              std::cerr,
+              "local health check failed");
+
+          if (result.statusCode > 0)
+          {
+            vix::cli::util::warn_line(
+                std::cerr,
+                "HTTP status: " + std::to_string(result.statusCode));
+          }
+
+          if (!result.error.empty())
+          {
+            vix::cli::util::warn_line(
+                std::cerr,
+                result.error);
+          }
+        }
+      }
+
+      if (cfg.healthPublic)
+      {
+        vix::cli::util::kv(std::cout, "Health public", *cfg.healthPublic);
+
+        const HealthResult result =
+            run_http_health_check(*cfg.healthPublic, cfg.healthTimeoutMs);
+
+        if (result.ok)
+        {
+          vix::cli::util::ok_line(
+              std::cout,
+              "public health check passed: HTTP " + std::to_string(result.statusCode));
+        }
+        else
+        {
+          ok = false;
+
+          vix::cli::util::err_line(
+              std::cerr,
+              "public health check failed");
+
+          if (result.statusCode > 0)
+          {
+            vix::cli::util::warn_line(
+                std::cerr,
+                "HTTP status: " + std::to_string(result.statusCode));
+          }
+
+          if (!result.error.empty())
+          {
+            vix::cli::util::warn_line(
+                std::cerr,
+                result.error);
+          }
+        }
+      }
+
+      if (!cfg.healthLocal && !cfg.healthPublic)
+      {
+        vix::cli::util::warn_line(
+            std::cerr,
+            "No health check configured.");
+
+        vix::cli::util::warn_line(
+            std::cerr,
+            "Add production.service.health_local or production.service.health_public to vix.json.");
+
+        return 1;
+      }
+
+      return ok ? 0 : 1;
+    }
+
     ServiceConfig load_service_config()
     {
       ServiceConfig cfg;
@@ -317,6 +463,15 @@ namespace vix::commands
           if (svc.contains("working_dir") && svc["working_dir"].is_string())
             cfg.workingDir = fs::path(svc["working_dir"].get<std::string>());
 
+          if (svc.contains("health_local") && svc["health_local"].is_string())
+            cfg.healthLocal = svc["health_local"].get<std::string>();
+
+          if (svc.contains("health_public") && svc["health_public"].is_string())
+            cfg.healthPublic = svc["health_public"].get<std::string>();
+
+          if (svc.contains("health_timeout_ms") && svc["health_timeout_ms"].is_number_unsigned())
+            cfg.healthTimeoutMs = svc["health_timeout_ms"].get<std::uint64_t>();
+
           if (svc.contains("exec") && svc["exec"].is_string())
           {
             const fs::path exec = svc["exec"].get<std::string>();
@@ -503,6 +658,9 @@ namespace vix::commands
     if (action == "install")
       return install_service();
 
+    if (action == "health")
+      return service_health();
+
     if (action == "start" ||
         action == "stop" ||
         action == "restart" ||
@@ -530,13 +688,14 @@ namespace vix::commands
         << "  stop        Stop the service\n"
         << "  restart     Restart the service\n"
         << "  status      Show service status\n"
-        << "  logs        Show recent service logs\n\n"
+        << "  logs        Show recent service logs\n"
+        << "  health      Run configured HTTP health checks\n\n"
         << "Examples:\n"
         << "  vix service install\n"
         << "  vix service restart\n"
         << "  vix service status\n"
-        << "  vix service logs\n";
-
+        << "  vix service logs\n"
+        << "  vix service health\n";
     return 0;
   }
 }

src/commands/deploy/DeployConfig.cpp

@@ -214,6 +214,12 @@ namespace vix::commands::deploy
     if (auto healthPublic = read_bool(deploy, "health_public"))
       cfg.healthPublic = *healthPublic;
 
+    if (auto proxyCheck = read_bool(deploy, "proxy_check"))
+      cfg.proxyCheck = *proxyCheck;
+
+    if (auto proxyReload = read_bool(deploy, "proxy_reload"))
+      cfg.proxyReload = *proxyReload;
+
     if (auto logs = read_bool(deploy, "logs_on_failure"))
       cfg.logsOnFailure = *logs;
 

src/commands/deploy/DeployOutput.cpp

@@ -46,6 +46,8 @@ namespace vix::commands::deploy::output
     vix::cli::util::kv(out, "Service", cfg.serviceName.empty() ? "(missing)" : cfg.serviceName);
     vix::cli::util::kv(out, "Health local", enabled_disabled(cfg.healthLocal));
     vix::cli::util::kv(out, "Health public", enabled_disabled(cfg.healthPublic));
+    vix::cli::util::kv(out, "Proxy check", enabled_disabled(cfg.proxyCheck));
+    vix::cli::util::kv(out, "Proxy reload", enabled_disabled(cfg.proxyReload));
     vix::cli::util::kv(out, "Logs on failure", enabled_disabled(cfg.logsOnFailure));
     vix::cli::util::kv(out, "Dry run", yes_no(options.dryRun));
     vix::cli::util::kv(out, "Verbose", yes_no(options.verbose));

src/commands/deploy/DeployRunner.cpp

@@ -147,28 +147,40 @@ namespace vix::commands::deploy::runner
       return run_cmd(cmd, options);
     }
 
-    bool health_local(
+    bool service_health(
         const DeployConfig &cfg,
         const DeployOptions &options)
     {
-      if (!cfg.healthLocal)
+      if (!cfg.healthLocal && !cfg.healthPublic)
         return true;
 
-      output::step(std::cout, "Local Health");
+      output::step(std::cout, "Service Health");
 
-      return run_cmd("vix health local", options);
+      return run_cmd("vix service health", options);
     }
 
-    bool health_public(
+    bool proxy_check(
         const DeployConfig &cfg,
         const DeployOptions &options)
     {
-      if (!cfg.healthPublic)
+      if (!cfg.proxyCheck && !cfg.proxyReload)
         return true;
 
-      output::step(std::cout, "Public Health");
+      output::step(std::cout, "Proxy Check");
 
-      return run_cmd("vix health public", options);
+      return run_cmd("vix proxy nginx check", options);
+    }
+
+    bool proxy_reload(
+        const DeployConfig &cfg,
+        const DeployOptions &options)
+    {
+      if (!cfg.proxyReload)
+        return true;
+
+      output::step(std::cout, "Proxy Reload");
+
+      return run_cmd("vix proxy nginx reload", options);
     }
   }
 
@@ -212,17 +224,23 @@ namespace vix::commands::deploy::runner
 
     output::ok(std::cout, "service is active");
 
-    if (!health_local(cfg, options))
-      return fail(cfg, options, "local health check failed", "run `vix health local`");
+    if (!service_health(cfg, options))
+      return fail(cfg, options, "service health check failed", "run `vix service health`");
+
+    if (cfg.healthLocal || cfg.healthPublic)
+      output::ok(std::cout, "service health checks passed");
+
+    if (!proxy_check(cfg, options))
+      return fail(cfg, options, "proxy check failed", "run `vix proxy nginx check`");
 
-    if (cfg.healthLocal)
-      output::ok(std::cout, "local endpoint is healthy");
+    if (cfg.proxyCheck || cfg.proxyReload)
+      output::ok(std::cout, "proxy config is valid");
 
-    if (!health_public(cfg, options))
-      return fail(cfg, options, "public health check failed", "run `vix health public`");
+    if (!proxy_reload(cfg, options))
+      return fail(cfg, options, "proxy reload failed", "run `vix proxy nginx reload`");
 
-    if (cfg.healthPublic)
-      output::ok(std::cout, "public endpoint is healthy");
+    if (cfg.proxyReload)
+      output::ok(std::cout, "proxy reloaded");
 
     output::ok(std::cout, "deployment completed");