538 lines
24 KiB
C++
538 lines
24 KiB
C++
// Lightweight RAII harness to start/stop a YamsDaemon for integration tests
|
|
#pragma once
|
|
|
|
#include <spdlog/sinks/stdout_color_sinks.h>
|
|
#include <spdlog/spdlog.h>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <optional>
|
|
#include <random>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <vector>
|
|
#include "test_async_helpers.h"
|
|
#include <yams/compat/unistd.h>
|
|
#include <yams/daemon/client/asio_connection_pool.h>
|
|
#include <yams/daemon/client/daemon_client.h>
|
|
#include <yams/daemon/client/global_io_context.h>
|
|
#include <yams/daemon/daemon.h>
|
|
|
|
#include <boost/asio/io_context.hpp>
|
|
#include <boost/asio/local/stream_protocol.hpp>
|
|
|
|
// Windows daemon IPC tests are currently unstable due to socket shutdown race conditions
|
|
// The daemon's connection handler coroutines crash during cleanup when sockets are forcibly closed
|
|
// See: docs/developer/windows-daemon-ipc-plan.md
|
|
#ifdef _WIN32
|
|
#define SKIP_DAEMON_TEST_ON_WINDOWS() \
|
|
SKIP("Daemon IPC tests unstable on Windows - see windows-daemon-ipc-plan.md")
|
|
#else
|
|
#define SKIP_DAEMON_TEST_ON_WINDOWS() ((void)0)
|
|
#endif
|
|
|
|
namespace yams::test {
|
|
|
|
// Options struct must be defined outside DaemonHarness to avoid Clang issue with
|
|
// default member initializers in nested structs used as default function arguments.
|
|
// See: https://bugs.llvm.org/show_bug.cgi?id=36684
|
|
struct DaemonHarnessOptions {
|
|
bool enableModelProvider = true;
|
|
bool useMockModelProvider = true;
|
|
bool autoLoadPlugins = false;
|
|
bool pluginDirStrict = false;
|
|
bool enableAutoRepair = true;
|
|
bool isolateState = false;
|
|
bool skipSocketVerificationOnReady = false;
|
|
bool configureModelPool = false;
|
|
bool modelPoolLazyLoading = true;
|
|
std::vector<std::string> preloadModels = {};
|
|
std::optional<std::filesystem::path> pluginDir = std::nullopt;
|
|
// Per-plugin configuration: plugin name -> JSON config string
|
|
std::map<std::string, std::string> pluginConfigs = {};
|
|
// Override the data directory instead of creating a temp one.
|
|
// When set, the harness uses this existing path (e.g. a real corpus)
|
|
// and skips cleanup of the data dir on destruction.
|
|
std::optional<std::filesystem::path> dataDir = std::nullopt;
|
|
// Optional fixture content to seed `dataDir` with. When both are set
|
|
// and `dataDir` exists but is empty (or doesn't exist), the harness
|
|
// recursively copies the fixture's contents into `dataDir` before
|
|
// starting the daemon. If `dataDir` is non-empty, no copy is performed
|
|
// (lets subsequent spawns reuse the seeded scratch dir, preserving
|
|
// tuner state / topology artifacts across runs). Useful for benches
|
|
// that want a writable scratch seeded from a frozen fixture.
|
|
std::optional<std::filesystem::path> cloneFixtureFrom = std::nullopt;
|
|
// Optional explicit config.toml path for daemon startup.
|
|
// When set, the harness points daemon config resolution at this file.
|
|
std::optional<std::filesystem::path> configPath = std::nullopt;
|
|
// Additional trusted plugin search paths (appended to DaemonConfig::trustedPluginPaths)
|
|
std::vector<std::filesystem::path> trustedPluginPaths = {};
|
|
// Optional test hook to mutate the daemon config before construction.
|
|
std::function<void(yams::daemon::DaemonConfig&)> configureDaemon;
|
|
};
|
|
|
|
class DaemonHarness {
|
|
public:
|
|
using Options = DaemonHarnessOptions;
|
|
|
|
explicit DaemonHarness(Options options = Options()) : options_(std::move(options)) {
|
|
namespace fs = std::filesystem;
|
|
// Ensure mock provider and disable ABI plugins for stability
|
|
// Create temp working dir
|
|
auto id = random_id();
|
|
root_ = fs::temp_directory_path() / (std::string("yams_it_") + id);
|
|
fs::create_directories(root_);
|
|
|
|
// Use caller-provided dataDir if set (e.g. existing corpus), else create temp
|
|
if (options_.dataDir) {
|
|
data_ = *options_.dataDir;
|
|
externalDataDir_ = true; // skip cleanup of external data
|
|
fs::create_directories(data_);
|
|
} else {
|
|
data_ = root_ / "data";
|
|
fs::create_directories(data_);
|
|
}
|
|
|
|
// Seed scratch from a fixture when requested AND the scratch is empty.
|
|
// Subsequent spawns reuse the existing content (preserves tuner state,
|
|
// topology artifacts, etc. across reps).
|
|
if (options_.cloneFixtureFrom) {
|
|
std::error_code ec;
|
|
const auto& src = *options_.cloneFixtureFrom;
|
|
bool dataDirEmpty = true;
|
|
if (fs::exists(data_)) {
|
|
for (auto it = fs::directory_iterator(data_, ec);
|
|
!ec && it != fs::directory_iterator(); ++it) {
|
|
dataDirEmpty = false;
|
|
break;
|
|
}
|
|
}
|
|
if (dataDirEmpty && fs::exists(src, ec)) {
|
|
fs::copy(src, data_,
|
|
fs::copy_options::recursive | fs::copy_options::copy_symlinks |
|
|
fs::copy_options::skip_existing,
|
|
ec);
|
|
if (ec) {
|
|
spdlog::warn("[DaemonHarness] cloneFixtureFrom copy failed: {} ({} -> {})",
|
|
ec.message(), src.string(), data_.string());
|
|
} else {
|
|
spdlog::info("[DaemonHarness] seeded {} from fixture {}", data_.string(),
|
|
src.string());
|
|
}
|
|
}
|
|
}
|
|
// Use platform-appropriate temp path for socket
|
|
// On Windows, AF_UNIX sockets work but need a valid Windows path
|
|
// On Unix, use /tmp for short paths to avoid AF_UNIX length limits
|
|
#ifdef _WIN32
|
|
sock_ = fs::temp_directory_path() / ("daemon_" + id + ".sock");
|
|
#else
|
|
sock_ = std::filesystem::path("/tmp") / ("daemon_" + id + ".sock");
|
|
#endif
|
|
pid_ = root_ / ("daemon_" + id + ".pid");
|
|
log_ = root_ / ("daemon_" + id + ".log");
|
|
|
|
// NOTE: Do NOT create daemon instance in constructor!
|
|
// Creating YamsDaemon initializes ServiceManager which spawns worker threads.
|
|
// If start() is never called but destructor runs, thread cleanup can crash.
|
|
// Defer daemon creation until start() is explicitly called.
|
|
}
|
|
|
|
~DaemonHarness() {
|
|
// Explicitly stop daemon before cleanup to avoid crashes
|
|
stop();
|
|
cleanup();
|
|
}
|
|
|
|
// Pre-runLoop callback type: called after daemon->start() succeeds but before runLoop thread
|
|
// starts. Use this to set signal check hooks or external shutdown flags BEFORE the runLoop
|
|
// begins reading them, avoiding race conditions.
|
|
using PreRunLoopCallback = std::function<void(yams::daemon::YamsDaemon*)>;
|
|
|
|
bool start(std::chrono::milliseconds timeout = std::chrono::seconds(10),
|
|
PreRunLoopCallback preRunLoopCallback = nullptr) {
|
|
ensureDefaultLogger();
|
|
// Always create new daemon instance on start()
|
|
// (daemon cannot be restarted after stop() - must create new instance)
|
|
spdlog::info("[DaemonHarness] Creating new daemon instance...");
|
|
|
|
if (options_.isolateState) {
|
|
originalCwd_ = std::filesystem::current_path();
|
|
std::filesystem::current_path(root_);
|
|
originalXdgState_ = std::getenv("XDG_STATE_HOME") ? std::getenv("XDG_STATE_HOME") : "";
|
|
setenv("XDG_STATE_HOME", (root_ / "state").string().c_str(), 1);
|
|
std::filesystem::create_directories(root_ / "state" / "yams" / "sessions");
|
|
isolateStateActive_ = true;
|
|
}
|
|
|
|
yams::daemon::DaemonConfig cfg;
|
|
if (options_.configPath) {
|
|
previousYamsConfig_ = std::getenv("YAMS_CONFIG") ? std::getenv("YAMS_CONFIG") : "";
|
|
hadYamsConfig_ = std::getenv("YAMS_CONFIG") != nullptr;
|
|
setenv("YAMS_CONFIG", options_.configPath->string().c_str(), 1);
|
|
configEnvOwned_ = true;
|
|
cfg.configFilePath = *options_.configPath;
|
|
}
|
|
cfg.dataDir = data_;
|
|
cfg.socketPath = sock_;
|
|
cfg.pidFile = pid_;
|
|
cfg.logFile = log_;
|
|
cfg.enableModelProvider = options_.enableModelProvider;
|
|
cfg.autoLoadPlugins = options_.autoLoadPlugins;
|
|
cfg.pluginDirStrict = options_.pluginDirStrict;
|
|
cfg.useMockModelProvider = options_.useMockModelProvider;
|
|
cfg.enableAutoRepair = options_.enableAutoRepair;
|
|
if (options_.pluginDir) {
|
|
cfg.pluginDir = *options_.pluginDir;
|
|
}
|
|
if (options_.configureModelPool) {
|
|
cfg.modelPoolConfig.lazyLoading = options_.modelPoolLazyLoading;
|
|
cfg.modelPoolConfig.preloadModels = options_.preloadModels;
|
|
}
|
|
if (options_.configureDaemon) {
|
|
options_.configureDaemon(cfg);
|
|
}
|
|
// Pass plugin-specific configurations
|
|
cfg.pluginConfigs = options_.pluginConfigs;
|
|
// Pass trusted plugin paths
|
|
cfg.trustedPluginPaths = options_.trustedPluginPaths;
|
|
daemon_ = std::make_unique<yams::daemon::YamsDaemon>(cfg);
|
|
spdlog::info("[DaemonHarness] Daemon instance created");
|
|
|
|
spdlog::info("[DaemonHarness] Calling daemon_->start()...");
|
|
auto s = daemon_->start();
|
|
if (!s) {
|
|
spdlog::error("[DaemonHarness] daemon_->start() failed!");
|
|
return false;
|
|
}
|
|
spdlog::info("[DaemonHarness] daemon_->start() succeeded, starting runLoop thread...");
|
|
|
|
// Call pre-runLoop callback if provided (for setting up signal hooks, etc.)
|
|
// This runs BEFORE the runLoop thread starts, avoiding race conditions.
|
|
if (preRunLoopCallback) {
|
|
spdlog::info("[DaemonHarness] Invoking pre-runLoop callback...");
|
|
preRunLoopCallback(daemon_.get());
|
|
}
|
|
|
|
#ifdef YAMS_TESTING
|
|
if (!preRunLoopCallback && !options_.enableAutoRepair) {
|
|
daemon_->testingStartAsyncInitWithoutRunLoop();
|
|
spdlog::info("[DaemonHarness] Async init triggered without runLoop thread, polling for "
|
|
"daemon Ready state...");
|
|
} else
|
|
#endif
|
|
{
|
|
// Start runLoop in background thread - this triggers async initialization
|
|
// Without runLoop(), ServiceManager::startAsyncInit() is never called
|
|
runLoopThread_ = std::thread([this]() {
|
|
daemon_->runLoop();
|
|
auto stopResult = daemon_->stop();
|
|
if (!stopResult && daemon_->isRunning()) {
|
|
spdlog::warn("[DaemonHarness] Background stop after runLoop returned error: {}",
|
|
stopResult.error().message);
|
|
}
|
|
});
|
|
// Give runLoop time to enter and trigger async init
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
|
spdlog::info(
|
|
"[DaemonHarness] runLoop thread started, polling for daemon Ready state...");
|
|
}
|
|
|
|
// Poll for daemon to reach a usable lifecycle state in lifecycle FSM.
|
|
// Ready or Degraded both indicate initialization completed enough for IPC tests.
|
|
auto deadline = std::chrono::steady_clock::now() + timeout;
|
|
bool lifecycleReady = false;
|
|
|
|
while (std::chrono::steady_clock::now() < deadline) {
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
|
|
// Check lifecycle state first
|
|
auto lifecycle = daemon_->getLifecycle().snapshot();
|
|
if (lifecycle.state == yams::daemon::LifecycleState::Ready ||
|
|
lifecycle.state == yams::daemon::LifecycleState::Degraded) {
|
|
lifecycleReady = true;
|
|
spdlog::info("[DaemonHarness] Daemon lifecycle reached usable state: {}",
|
|
static_cast<int>(lifecycle.state));
|
|
break;
|
|
} else if (lifecycle.state == yams::daemon::LifecycleState::Failed) {
|
|
spdlog::error("[DaemonHarness] Daemon lifecycle reached Failed state: {}",
|
|
lifecycle.lastError);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!lifecycleReady) {
|
|
auto lifecycle = daemon_->getLifecycle().snapshot();
|
|
spdlog::error(
|
|
"[DaemonHarness] Timeout waiting for Ready state after {}ms (current state: {})",
|
|
timeout.count(), static_cast<int>(lifecycle.state));
|
|
return false;
|
|
}
|
|
|
|
// Verify socket connectivity as final sanity check
|
|
// Use simple socket connection instead of DaemonClient to avoid polluting
|
|
// the shared connection pool (DaemonClient destructor shuts down shared pools)
|
|
if (options_.skipSocketVerificationOnReady) {
|
|
spdlog::info(
|
|
"[DaemonHarness] Skipping socket verification after Ready (test override)");
|
|
return true;
|
|
}
|
|
|
|
spdlog::info("[DaemonHarness] Verifying socket connectivity at: {}", sock_.string());
|
|
bool socketOk = verifySocketConnectivity(sock_, std::chrono::seconds(5));
|
|
if (socketOk) {
|
|
spdlog::info("[DaemonHarness] Socket connection verified, daemon fully ready at: {}",
|
|
sock_.string());
|
|
return true;
|
|
}
|
|
spdlog::error("[DaemonHarness] Daemon Ready but socket connection failed at: {}",
|
|
sock_.string());
|
|
return false;
|
|
}
|
|
|
|
void stop() {
|
|
if (std::getenv("YAMS_TRACE_HARNESS_LIFETIME")) {
|
|
std::fprintf(stderr, "[DaemonHarness::stop] enter daemon=%p runLoopJoinable=%d\n",
|
|
static_cast<void*>(daemon_.get()), runLoopThread_.joinable() ? 1 : 0);
|
|
std::fflush(stderr);
|
|
}
|
|
if (daemon_) {
|
|
spdlog::info("[DaemonHarness] Stopping daemon (running={})...", daemon_->isRunning());
|
|
|
|
if (runLoopThread_.joinable()) {
|
|
spdlog::info("[DaemonHarness] Requesting runLoop stop before join...");
|
|
daemon_->requestStop();
|
|
spdlog::info("[DaemonHarness] Joining runLoop thread...");
|
|
runLoopThread_.join();
|
|
spdlog::info("[DaemonHarness] runLoop thread joined");
|
|
}
|
|
|
|
// Wait for daemon to fully stop - the background runLoop thread mirrors
|
|
// daemon_main by calling stop() after runLoop() returns on remote shutdown.
|
|
if (daemon_->isRunning() ||
|
|
!daemon_->waitForStopCompletion(std::chrono::milliseconds(0))) {
|
|
auto stopResult = daemon_->stop();
|
|
if (!stopResult) {
|
|
spdlog::warn("[DaemonHarness] Daemon stop returned error: {}",
|
|
stopResult.error().message);
|
|
}
|
|
}
|
|
|
|
// Wait for daemon to report it's no longer running
|
|
int isRunningRetries = 0;
|
|
while (daemon_->isRunning() && isRunningRetries < 50) {
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
isRunningRetries++;
|
|
}
|
|
if (isRunningRetries > 0) {
|
|
spdlog::info("[DaemonHarness] Waited {}ms for isRunning() to become false",
|
|
isRunningRetries * 10);
|
|
}
|
|
|
|
spdlog::info("[DaemonHarness] Daemon stopped (running={}), resetting instance...",
|
|
daemon_->isRunning());
|
|
|
|
// Reset GlobalIOContext to clean up threads and io_context state
|
|
// This is critical for test isolation - without it, threads accumulate across test
|
|
// cases Temporarily unset YAMS_TESTING to allow reset() to actually work
|
|
const char* yams_testing_env = std::getenv("YAMS_TESTING");
|
|
const char* yams_safe_env = std::getenv("YAMS_TEST_SAFE_SINGLE_INSTANCE");
|
|
std::string yams_testing = yams_testing_env ? yams_testing_env : "";
|
|
std::string yams_safe = yams_safe_env ? yams_safe_env : "";
|
|
if (yams_testing_env) {
|
|
unsetenv("YAMS_TESTING");
|
|
}
|
|
if (yams_safe_env) {
|
|
unsetenv("YAMS_TEST_SAFE_SINGLE_INSTANCE");
|
|
}
|
|
|
|
// Reset the global client IO state BEFORE restarting threads.
|
|
// This closes ConnectionRegistry sockets and clears pools while the
|
|
// existing io_context is still alive, preventing stale client FDs
|
|
// from accumulating across harness cycles.
|
|
yams::daemon::GlobalIOContext::reset();
|
|
spdlog::info("[DaemonHarness] GlobalIOContext reset complete");
|
|
|
|
// Windows needs additional time before GlobalIOContext::reset()
|
|
// Windows thread cleanup is slower than Unix
|
|
#ifdef _WIN32
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
// Skip GlobalIOContext operations on Windows for now - causes SIGSEGV
|
|
// The io_context threads will be cleaned up when the process exits
|
|
spdlog::info("[DaemonHarness] Skipping GlobalIOContext::restart() on Windows");
|
|
#else
|
|
spdlog::info("[DaemonHarness] GlobalIOContext restart deferred");
|
|
#endif
|
|
|
|
// Restore environment variables
|
|
if (yams_testing_env) {
|
|
setenv("YAMS_TESTING", yams_testing.c_str(), 1);
|
|
}
|
|
if (yams_safe_env) {
|
|
setenv("YAMS_TEST_SAFE_SINGLE_INSTANCE", yams_safe.c_str(), 1);
|
|
}
|
|
|
|
if (isolateStateActive_) {
|
|
std::error_code ec;
|
|
if (!originalCwd_.empty()) {
|
|
std::filesystem::current_path(originalCwd_, ec);
|
|
}
|
|
if (originalXdgState_.empty()) {
|
|
unsetenv("XDG_STATE_HOME");
|
|
} else {
|
|
setenv("XDG_STATE_HOME", originalXdgState_.c_str(), 1);
|
|
}
|
|
isolateStateActive_ = false;
|
|
}
|
|
|
|
if (configEnvOwned_) {
|
|
if (hadYamsConfig_) {
|
|
setenv("YAMS_CONFIG", previousYamsConfig_.c_str(), 1);
|
|
} else {
|
|
unsetenv("YAMS_CONFIG");
|
|
}
|
|
configEnvOwned_ = false;
|
|
hadYamsConfig_ = false;
|
|
previousYamsConfig_.clear();
|
|
}
|
|
|
|
// Reset daemon so it can be recreated on next start()
|
|
daemon_.reset();
|
|
|
|
if (std::getenv("YAMS_TRACE_HARNESS_LIFETIME")) {
|
|
std::fprintf(stderr, "[DaemonHarness::stop] exit daemon=%p runLoopJoinable=%d\n",
|
|
static_cast<void*>(daemon_.get()), runLoopThread_.joinable() ? 1 : 0);
|
|
std::fflush(stderr);
|
|
}
|
|
|
|
// CRITICAL: Allow OS to fully release thread resources (macOS needs this)
|
|
// Each daemon creates ~48 threads (32 SocketServer + 16 ServiceManager).
|
|
// macOS has strict per-process thread creation rate limits and needs time
|
|
// to reclaim thread resources before next daemon starts creating threads.
|
|
// Testing shows: 250ms → crashes at daemon #6, 500ms allows ~10 daemons, 750ms more
|
|
// conservative. Increased to 750ms for improved stability on resource-constrained CI
|
|
// runners.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(
|
|
750)); // Wait for socket file to be removed by daemon shutdown
|
|
int socketRetries = 0;
|
|
while (std::filesystem::exists(sock_) && socketRetries < 50) {
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
socketRetries++;
|
|
}
|
|
|
|
if (socketRetries > 0) {
|
|
spdlog::info("[DaemonHarness] Waited {}ms for socket file removal",
|
|
socketRetries * 20);
|
|
}
|
|
|
|
// Verify socket is truly gone
|
|
if (std::filesystem::exists(sock_)) {
|
|
spdlog::warn("[DaemonHarness] Socket file still exists after {}ms",
|
|
socketRetries * 20);
|
|
}
|
|
|
|
// Additional brief wait to ensure OS fully releases socket
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
|
|
spdlog::info(
|
|
"[DaemonHarness] Stop complete (isRunning check: {}ms, socket cleanup: {}ms)",
|
|
isRunningRetries * 10, socketRetries * 20);
|
|
}
|
|
}
|
|
|
|
const std::filesystem::path& socketPath() const { return sock_; }
|
|
const std::filesystem::path& dataDir() const { return data_; }
|
|
const std::filesystem::path& rootDir() const { return root_; }
|
|
yams::daemon::YamsDaemon* daemon() const { return daemon_.get(); }
|
|
|
|
private:
|
|
// Install a default spdlog logger once per process if none exists, so plugins
|
|
// and harness code that call spdlog::info(...) don't dereference a null default
|
|
// logger. Mirrors daemon_main's init order (set_default_logger before plugin load).
|
|
static void ensureDefaultLogger() {
|
|
static const bool once = [] {
|
|
if (!spdlog::default_logger()) {
|
|
try {
|
|
auto sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
|
|
auto logger = std::make_shared<spdlog::logger>("yams-test", sink);
|
|
spdlog::set_default_logger(logger);
|
|
} catch (...) {
|
|
}
|
|
}
|
|
return true;
|
|
}();
|
|
(void)once;
|
|
}
|
|
|
|
static std::string random_id() {
|
|
static const char* cs = "abcdefghijklmnopqrstuvwxyz0123456789";
|
|
thread_local std::mt19937_64 rng{std::random_device{}()};
|
|
std::uniform_int_distribution<size_t> dist(0, 35);
|
|
std::string out;
|
|
out.reserve(8);
|
|
for (int i = 0; i < 8; ++i)
|
|
out.push_back(cs[dist(rng)]);
|
|
return out;
|
|
}
|
|
|
|
// Simple socket connectivity check that doesn't use the shared connection pool
|
|
// This avoids DaemonClient's destructor from shutting down the pool before
|
|
// the actual test fixture's client can use it
|
|
static bool verifySocketConnectivity(const std::filesystem::path& socketPath,
|
|
std::chrono::milliseconds timeout) {
|
|
auto deadline = std::chrono::steady_clock::now() + timeout;
|
|
while (std::chrono::steady_clock::now() < deadline) {
|
|
try {
|
|
// Create fresh socket for each attempt (can't reuse after failed connect)
|
|
boost::asio::io_context io;
|
|
boost::asio::local::stream_protocol::socket sock(io);
|
|
boost::system::error_code ec;
|
|
|
|
sock.connect(boost::asio::local::stream_protocol::endpoint(socketPath.string()),
|
|
ec);
|
|
if (!ec) {
|
|
sock.close();
|
|
return true;
|
|
}
|
|
} catch (const std::exception& e) {
|
|
spdlog::debug("[DaemonHarness] Socket verification attempt failed: {}", e.what());
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
|
}
|
|
spdlog::error("[DaemonHarness] Socket verification timed out after {}ms", timeout.count());
|
|
return false;
|
|
}
|
|
void cleanup() {
|
|
namespace fs = std::filesystem;
|
|
std::error_code ec;
|
|
if (externalDataDir_) {
|
|
// Only remove temp root (socket, pid, log) — preserve external data dir
|
|
if (!root_.empty()) {
|
|
// Remove everything in root_ except data_ (which is external)
|
|
for (auto& entry : fs::directory_iterator(root_, ec)) {
|
|
fs::remove_all(entry.path(), ec);
|
|
}
|
|
fs::remove(root_, ec);
|
|
}
|
|
} else {
|
|
if (!root_.empty())
|
|
fs::remove_all(root_, ec);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<yams::daemon::YamsDaemon> daemon_;
|
|
std::thread runLoopThread_; // Background thread for runLoop
|
|
std::filesystem::path root_, data_, sock_, pid_, log_;
|
|
std::filesystem::path originalCwd_;
|
|
std::string originalXdgState_;
|
|
std::string previousYamsConfig_;
|
|
bool isolateStateActive_ = false;
|
|
bool externalDataDir_ = false;
|
|
bool configEnvOwned_ = false;
|
|
bool hadYamsConfig_ = false;
|
|
Options options_;
|
|
};
|
|
|
|
} // namespace yams::test
|