feat(deploy): add rollback and failure log analysis

Author: GaspardKirira

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

@@ -110,6 +110,11 @@ namespace vix::commands::deploy
      */
     bool logsOnFailure{true};
 
+    /**
+     * @brief Whether deploy should attempt rollback on failure.
+     */
+    bool rollback{false};
+
     /**
      * @brief Number of journalctl log lines shown on failure.
      */

src/commands/DeployCommand.cpp

@@ -124,7 +124,16 @@ namespace vix::commands
         << "  production.deploy.health_public\n"
         << "  production.deploy.proxy_check\n"
         << "  production.deploy.proxy_reload\n"
-        << "  production.deploy.logs_on_failure\n";
+        << "  production.deploy.logs_on_failure\n"
+        << "  production.deploy.log_lines\n"
+        << "  production.deploy.rollback\n"
+        << "  production.health.service\n"
+        << "  production.health.local\n"
+        << "  production.health.public\n"
+        << "  production.health.websocket\n"
+        << "  production.logs.service\n"
+        << "  production.logs.nginx_access\n"
+        << "  production.logs.nginx_error\n";
 
     return 0;
   }

src/commands/deploy/DeployConfig.cpp

@@ -223,6 +223,9 @@ namespace vix::commands::deploy
     if (auto logs = read_bool(deploy, "logs_on_failure"))
       cfg.logsOnFailure = *logs;
 
+    if (auto rollback = read_bool(deploy, "rollback"))
+      cfg.rollback = *rollback;
+
     if (auto lines = read_int(deploy, "log_lines"))
       cfg.logLines = *lines;
 

src/commands/deploy/DeployOutput.cpp

@@ -49,6 +49,7 @@ namespace vix::commands::deploy::output
     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, "Rollback", enabled_disabled(cfg.rollback));
     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

@@ -16,6 +16,10 @@
 #include <cstdlib>
 #include <iostream>
 #include <string>
+#include <array>
+#include <cstdio>
+#include <memory>
+#include <optional>
 
 namespace vix::commands::deploy::runner
 {
@@ -49,6 +53,41 @@ namespace vix::commands::deploy::runner
       return std::system(cmd.c_str()) == 0;
     }
 
+    std::optional<std::string> run_capture(const std::string &cmd)
+    {
+      std::array<char, 2048> buffer{};
+      std::string output;
+
+      std::unique_ptr<FILE, decltype(&pclose)> pipe(
+          popen(cmd.c_str(), "r"),
+          pclose);
+
+      if (!pipe)
+        return std::nullopt;
+
+      while (fgets(buffer.data(), static_cast<int>(buffer.size()), pipe.get()) != nullptr)
+        output += buffer.data();
+
+      while (!output.empty() &&
+             (output.back() == '\n' ||
+              output.back() == '\r' ||
+              output.back() == ' ' ||
+              output.back() == '\t'))
+      {
+        output.pop_back();
+      }
+
+      if (output.empty())
+        return std::nullopt;
+
+      return output;
+    }
+
+    struct DeployState
+    {
+      std::string previousGitRef{};
+    };
+
     int fail(
         const DeployConfig &cfg,
         const DeployOptions &options,
@@ -60,16 +99,86 @@ namespace vix::commands::deploy::runner
       if (!fixMessage.empty())
         output::fix(std::cerr, fixMessage);
 
-      if (cfg.logsOnFailure && !cfg.serviceName.empty())
+      if (cfg.logsOnFailure)
+      {
+        const std::string logsCmd =
+            "vix logs errors --repeated -n " +
+            std::to_string(cfg.logLines);
+
+        output::step(std::cout, "Failure Logs");
+        output::command(std::cout, logsCmd);
+
+        if (!options.dryRun)
+          (void)std::system(logsCmd.c_str());
+      }
+
+      return 1;
+    }
+
+    bool rollback_deploy(
+        const DeployConfig &cfg,
+        const DeployOptions &options,
+        const DeployState &state)
+    {
+      if (!cfg.rollback)
+        return true;
+
+      if (state.previousGitRef.empty())
+      {
+        output::warn(std::cerr, "rollback skipped: no previous git revision captured");
+        return false;
+      }
+
+      output::step(std::cout, "Rollback");
+
+      const std::string resetCmd =
+          "git reset --hard " +
+          shell_quote(state.previousGitRef);
+
+      if (!run_cmd(resetCmd, options))
+        return false;
+
+      if (!run_cmd(cfg.buildCommand, options))
+        return false;
+
+      if (!run_cmd("vix service restart", options))
+        return false;
+
+      if (!run_cmd("vix service status", options))
+        return false;
+
+      output::ok(std::cout, "rollback completed");
+      return true;
+    }
+
+    int fail_with_rollback(
+        const DeployConfig &cfg,
+        const DeployOptions &options,
+        const DeployState &state,
+        const std::string &message,
+        const std::string &fixMessage = {})
+    {
+      output::error(std::cerr, message);
+
+      if (!fixMessage.empty())
+        output::fix(std::cerr, fixMessage);
+
+      if (cfg.rollback)
+      {
+        if (!rollback_deploy(cfg, options, state))
+        {
+          output::error(std::cerr, "rollback failed");
+          output::fix(std::cerr, "inspect the repository and service manually");
+        }
+      }
+
+      if (cfg.logsOnFailure)
       {
         const std::string logsCmd =
-            "sudo journalctl -u " +
-            shell_quote(cfg.serviceName) +
-            " -n " +
-            std::to_string(cfg.logLines) +
-            " --no-pager";
+            "vix logs errors --repeated -n " +
+            std::to_string(cfg.logLines);
 
-        output::step(std::cout, "Last Logs");
+        output::step(std::cout, "Failure Logs");
         output::command(std::cout, logsCmd);
 
         if (!options.dryRun)
@@ -124,11 +233,7 @@ namespace vix::commands::deploy::runner
 
       output::step(std::cout, "Restart Service");
 
-      const std::string cmd =
-          "sudo systemctl restart " +
-          shell_quote(cfg.serviceName);
-
-      return run_cmd(cmd, options);
+      return run_cmd("vix service restart", options);
     }
 
     bool verify_service(
@@ -140,23 +245,19 @@ namespace vix::commands::deploy::runner
 
       output::step(std::cout, "Service Status");
 
-      const std::string cmd =
-          "systemctl is-active --quiet " +
-          shell_quote(cfg.serviceName);
-
-      return run_cmd(cmd, options);
+      return run_cmd("vix service status", options);
     }
 
-    bool service_health(
+    bool health_check(
         const DeployConfig &cfg,
         const DeployOptions &options)
     {
       if (!cfg.healthLocal && !cfg.healthPublic)
         return true;
 
-      output::step(std::cout, "Service Health");
+      output::step(std::cout, "Health Check");
 
-      return run_cmd("vix service health", options);
+      return run_cmd("vix health", options);
     }
 
     bool proxy_check(
@@ -190,6 +291,18 @@ namespace vix::commands::deploy::runner
   {
     output::print_summary(std::cout, cfg, options);
 
+    DeployState state;
+
+    if (cfg.rollback && !options.dryRun)
+    {
+      const auto ref = run_capture("git rev-parse HEAD 2>/dev/null");
+
+      if (ref)
+        state.previousGitRef = *ref;
+      else
+        output::warn(std::cerr, "rollback enabled but current git revision could not be captured");
+    }
+
     if (cfg.serviceName.empty())
     {
       output::error(std::cerr, "Missing deployment service name.");
@@ -198,46 +311,102 @@ namespace vix::commands::deploy::runner
     }
 
     if (!pull_latest(cfg, options))
-      return fail(cfg, options, "git pull failed", "check repository state and branch");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "git pull failed",
+          "check repository state and branch");
+    }
 
     if (cfg.pull)
       output::ok(std::cout, "git pull completed");
 
     if (!build_app(cfg, options))
-      return fail(cfg, options, "build failed", "run the configured build command manually");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "build failed",
+          "run the configured build command manually");
+    }
 
     output::ok(std::cout, "build completed");
 
     if (!run_tests(cfg, options))
-      return fail(cfg, options, "tests failed", "run the configured test command manually");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "tests failed",
+          "run the configured test command manually");
+    }
 
     if (cfg.tests)
       output::ok(std::cout, "tests completed");
 
     if (!restart_service(cfg, options))
-      return fail(cfg, options, "service restart failed", "run `vix service restart`");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "service restart failed",
+          "run `vix service restart`");
+    }
 
     output::ok(std::cout, "service restarted");
 
     if (!verify_service(cfg, options))
-      return fail(cfg, options, "service is not active", "run `vix service status`");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "service is not active",
+          "run `vix service status`");
+    }
 
     output::ok(std::cout, "service is active");
 
-    if (!service_health(cfg, options))
-      return fail(cfg, options, "service health check failed", "run `vix service health`");
+    if (!health_check(cfg, options))
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "health check failed",
+          "run `vix health`");
+    }
 
     if (cfg.healthLocal || cfg.healthPublic)
-      output::ok(std::cout, "service health checks passed");
+      output::ok(std::cout, "health checks passed");
 
     if (!proxy_check(cfg, options))
-      return fail(cfg, options, "proxy check failed", "run `vix proxy nginx check`");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "proxy check failed",
+          "run `vix proxy nginx check`");
+    }
 
     if (cfg.proxyCheck || cfg.proxyReload)
       output::ok(std::cout, "proxy config is valid");
 
     if (!proxy_reload(cfg, options))
-      return fail(cfg, options, "proxy reload failed", "run `vix proxy nginx reload`");
+    {
+      return fail_with_rollback(
+          cfg,
+          options,
+          state,
+          "proxy reload failed",
+          "run `vix proxy nginx reload`");
+    }
 
     if (cfg.proxyReload)
       output::ok(std::cout, "proxy reloaded");