HotReload.cpp

浏览该文件的文档.

#include "filesystem/HotReload.h"
 
#include "common/AssetReloader.h"
#include "common/Capability.h"
#include "common/Module.h"
#include "common/StartupTiming.h"
#include "filesystem/Filesystem.h"
 
#ifndef EVENGINE_WEBGPU
#include <Poco/Exception.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/Object.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/Stringifier.h>
#include <Poco/Net/HTTPClientSession.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/Net/HTTPResponse.h>
#include <Poco/StreamCopier.h>
#include <Poco/Timespan.h>
#include <Poco/URI.h>
#endif
 
#include <simplesquirrel/simplesquirrel.hpp>
 
#if defined(EVENGINE_ANDROID)
#include "android/android.h"
#include <SDL2/SDL.h>
#elif defined(EVENGINE_IOS)
#include "ios/ios.h"
#endif
 
#include <cctype>
#include <chrono>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <string>
#include <system_error>
#include <vector>
 
namespace eve::filesystem {
namespace {
 
std::string joinDir(const std::string &dir, const std::string &name) {
    if (dir.empty() || dir == ".") return name;
    if (dir.back() == '/' || dir.back() == '\\') return dir + name;
    return dir + "/" + name;
}
 
std::filesystem::path pathFromUtf8(const std::string &text) {
    const auto *data = reinterpret_cast<const char8_t *>(text.data());
    return std::filesystem::path(std::u8string_view(data, text.size()));
}
 
std::string pathToUtf8(const std::filesystem::path &p) {
    auto u8 = p.u8string();
    return std::string(reinterpret_cast<const char *>(u8.data()), u8.size());
}
 
bool looksAbsoluteOs(const std::string &path) {
    if (path.empty()) return false;
    if (path[0] == '/' || path[0] == '\\') return true;
#ifdef _WIN32
    if (path.size() >= 2 && path[1] == ':') return true;
#endif
    return false;
}
 
bool hasParentSegment(const std::string &path) {
    if (path == "..") return true;
    if (path.size() >= 3 && (path.compare(0, 3, "../") == 0 || path.compare(0, 3, "..\\") == 0))
        return true;
    return path.find("/..") != std::string::npos || path.find("\\..") != std::string::npos;
}
 
bool skipWatchDirName(const std::string &name) {
    return name == ".git" || name == "build" || name == "third-party" || name == "node_modules" ||
           name == ".cursor" || name == ".local-debug" || name == "CMakeFiles";
}
 
std::string posixRelative(const std::filesystem::path &dir, const std::filesystem::path &root) {
    std::error_code ec;
    auto rel = std::filesystem::relative(dir, root, ec);
    if (ec) return {};
    std::string s = rel.generic_string();
    if (s.empty()) return ".";
    return s;
}
 
bool isPathPrefix(const std::filesystem::path &prefix, const std::filesystem::path &full) {
    std::error_code ec;
    auto a = std::filesystem::weakly_canonical(prefix, ec);
    if (ec) a = prefix.lexically_normal();
    auto b = std::filesystem::weakly_canonical(full, ec);
    if (ec) b = full.lexically_normal();
    std::string as = a.generic_string();
    std::string bs = b.generic_string();
    if (as.size() > bs.size()) return false;
#ifdef _WIN32
    for (char &ch : as) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
    for (char &ch : bs) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
#endif
    if (bs.compare(0, as.size(), as) != 0) return false;
    return bs.size() == as.size() || bs[as.size()] == '/';
}
 
int watchTreeVfs(Filesystem *fs, const std::string &root) {
    int added = 0;
    std::vector<std::string> stack;
    stack.push_back(root == "." ? std::string(".") : root);
 
    while (!stack.empty()) {
        std::string dir = stack.back();
        stack.pop_back();
        if (fs->watch(dir)) ++added;
 
        std::vector<std::string> items;
        try {
            if (dir == "." || dir.empty())
                items = fs->getDirectoryItems("");
            else
                items = fs->getDirectoryItems(dir);
        } catch (...) {
            continue;
        }
 
        for (const auto &item : items) {
            if (item.empty() || item == "." || item == "..") continue;
            const std::string child = (dir == "." || dir.empty()) ? item : joinDir(dir, item);
            Filesystem::Info info{};
            if (!fs->getInfo(child, info)) continue;
            if (info.type == "directory") stack.push_back(child);
        }
    }
    return added;
}
 
int watchTreeOs(Filesystem *fs, const std::filesystem::path &realRoot) {
    std::error_code ec;
    if (!std::filesystem::is_directory(realRoot, ec)) return 0;
 
    const auto cwd = pathFromUtf8(fs->getWorkingDirectory());
    auto reportFor = [&](const std::filesystem::path &dir) -> std::string {
        std::error_code canonEc;
        auto d = std::filesystem::weakly_canonical(dir, canonEc);
        if (canonEc) d = dir;
        auto c = std::filesystem::weakly_canonical(cwd, canonEc);
        if (canonEc) c = cwd;
        if (isPathPrefix(c, d)) {
            const std::string rel = posixRelative(d, c);
            return rel.empty() ? "." : rel;
        }
        const std::string rel = posixRelative(d, realRoot);
        return rel.empty() ? "." : rel;
    };
 
    int added = 0;
    if (fs->watchRealDirectory(pathToUtf8(realRoot), reportFor(realRoot)).ok()) ++added;
 
    auto it = std::filesystem::recursive_directory_iterator(
        realRoot, std::filesystem::directory_options::skip_permission_denied, ec);
    const auto end = std::filesystem::recursive_directory_iterator();
    for (; it != end; it.increment(ec)) {
        if (ec) {
            ec.clear();
            continue;
        }
        std::error_code dirEc;
        if (!it->is_directory(dirEc)) continue;
        const auto name = it->path().filename().string();
        if (name.empty() || name == "." || name == ".." || skipWatchDirName(name)) {
            it.disable_recursion_pending();
            continue;
        }
        const auto &dir = it->path();
        // When watching a parent workflow, skip sibling apps (apps/battle while
        // running apps/skill) but keep the current working directory.
        if (isPathPrefix(realRoot, cwd)) {
            const auto appsDir = cwd.parent_path();
            if (isPathPrefix(appsDir, dir) && !isPathPrefix(dir, appsDir) && !isPathPrefix(cwd, dir)) {
                it.disable_recursion_pending();
                continue;
            }
        }
        const std::string report = reportFor(dir);
        if (report.empty() || report.find("..") != std::string::npos) continue;
        if (fs->watchRealDirectory(pathToUtf8(dir), report).ok()) ++added;
    }
    return added;
}
 
bool resolveOsWatchRoot(Filesystem *fs, const std::string &root, std::filesystem::path &out) {
    std::error_code ec;
    std::filesystem::path candidate;
    if (root == "." || root == "./") {
        candidate = pathFromUtf8(fs->getWorkingDirectory());
    } else if (looksAbsoluteOs(root)) {
        candidate = pathFromUtf8(root);
    } else {
        candidate = pathFromUtf8(fs->getWorkingDirectory()) / pathFromUtf8(root);
    }
    auto canonical = std::filesystem::weakly_canonical(candidate, ec);
    if (ec) return false;
    if (!std::filesystem::is_directory(canonical, ec)) return false;
    out = canonical;
    return true;
}
 
// --- Remote sync helpers ---
 
#ifndef EVENGINE_WEBGPU
std::string stripTrailingSlash(std::string s) {
    while (s.size() > 1 && s.back() == '/') s.pop_back();
    return s;
}
 
// Path-escape for use inside a URL path segment (spaces, '#', '?', etc.).
std::string urlPathEscape(const std::string &s) {
    std::string out;
    out.reserve(s.size() + 8);
    const char hex[] = "0123456789ABCDEF";
    for (unsigned char c : s) {
        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~' || c == '/') {
            out += static_cast<char>(c);
        } else {
            out += '%';
            out += hex[c >> 4];
            out += hex[c & 0xF];
        }
    }
    return out;
}
 
// HTTP GET; returns 200 response body or empty on failure.
std::string httpGet(const std::string &url, int timeoutMs) {
    try {
        Poco::URI uri(url);
        Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
        session.setTimeout(Poco::Timespan(timeoutMs / 1000, (timeoutMs % 1000) * 1000));
        std::string path = uri.getPathAndQuery();
        if (path.empty()) path = "/";
        Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, path,
                                   Poco::Net::HTTPMessage::HTTP_1_1);
        req.setHost(uri.getHost());
        std::ostream &os = session.sendRequest(req);
        (void)os;
        Poco::Net::HTTPResponse resp;
        std::istream &is = session.receiveResponse(resp);
        if (resp.getStatus() != Poco::Net::HTTPResponse::HTTP_OK) return {};
        std::ostringstream oss;
        Poco::StreamCopier::copyStream(is, oss);
        return oss.str();
    } catch (...) {
        return {};
    }
}
 
bool writeFileBytes(const std::string &realPath, const std::string &data) {
    std::error_code ec;
    std::filesystem::path p(realPath);
    std::filesystem::create_directories(p.parent_path(), ec);
    std::ofstream ofs(realPath, std::ios::binary | std::ios::trunc);
    if (!ofs) return false;
    ofs.write(data.data(), static_cast<std::streamsize>(data.size()));
    return ofs.good();
}
#endif  // !EVENGINE_WEBGPU
 
}  // namespace
 
Module_IMPL(HotReload, new HotReload());
 
HotReload::~HotReload() { stopRemoteSync(); }
 
std::string HotReload::normalizePath(std::string path) {
    for (char &c : path) {
        if (c == '\\') c = '/';
    }
    while (path.size() >= 2 && path[0] == '.' && path[1] == '/') path.erase(0, 2);
    while (path.size() > 1 && path.back() == '/') path.pop_back();
    return path;
}
 
void HotReload::bind(std::string path, std::string kind) {
    path = normalizePath(std::move(path));
    if (path.empty()) return;
    if (kind.empty()) kind = "auto";
    bindings_[path] = kind;
}
 
void HotReload::unbind(std::string path) {
    bindings_.erase(normalizePath(std::move(path)));
}
 
bool HotReload::tryReload(std::string path) {
    const std::string norm = normalizePath(std::move(path));
    if (norm.empty()) return false;
 
    std::string kind = "auto";
    auto bit = bindings_.find(norm);
    if (bit != bindings_.end()) kind = bit->second;
 
    bool any = false;
    eve::cap::forEach<eve::caps::IAssetReloader>([&](eve::caps::IAssetReloader *r) {
        // "auto" lets each reloader claim the path by extension. An explicit
        // kind targets exactly one reloader and ignores the extension, so a
        // config file with an unexpected suffix can still be bound by hand.
        const bool wanted = (kind == "auto") ? r->handlesPath(norm) : (kind == r->reloadKind());
        if (!wanted) return;
        auto result = r->reload(norm);
        if (result.ok() && result.value()) any = true;
    });
    return any;
}
 
int HotReload::watchTree(std::string root) {
    StartupStage stage("hotreload: watchTree (recursive walk + register watches)");
    auto *fs = Filesystem::create();
    if (!fs) return 0;
    root = normalizePath(std::move(root));
    if (root.empty()) root = ".";
 
    Filesystem::Info info{};
    const bool vfsDir = (root == "." || root == "./") ||
                        (!looksAbsoluteOs(root) && !hasParentSegment(root) && fs->getInfo(root, info) &&
                         info.type == "directory");
    if (vfsDir) return watchTreeVfs(fs, root);
 
    std::filesystem::path realRoot;
    if (!resolveOsWatchRoot(fs, root, realRoot)) return 0;
    return watchTreeOs(fs, realRoot);
}
 
bool HotReload::watchNewDirectory(std::string path) {
    auto *fs = Filesystem::create();
    if (!fs) return false;
    path = normalizePath(std::move(path));
    if (path.empty()) return false;
 
    Filesystem::Info info{};
    if (fs->getInfo(path, info) && info.type == "directory") {
        watchTree(path);
        return true;
    }
    std::filesystem::path real;
    if (!resolveOsWatchRoot(fs, path, real)) return false;
    watchTreeOs(fs, real);
    return true;
}
 
// --- Remote hot reload (dev-server sync) ---
// Poco (HTTP) is not available in the Emscripten/WebGPU build; the API is
// stubbed there so scripts still compile, and startRemoteSync just fails.
 
#ifndef EVENGINE_WEBGPU
 
std::string HotReload::ensureHotDir() {
    if (!hotDir_.empty()) return hotDir_;
 
    std::string base;
#if defined(EVENGINE_ANDROID)
    base = eve::android::getHotReloadDirectory();
#elif defined(EVENGINE_IOS)
    base = eve::ios::getHotReloadDirectory();
#else
    {
        auto *fs = Filesystem::create();
        base = fs ? fs->getAppdataDirectory() : std::string(".");
        if (!base.empty() && base.back() == '/') base.pop_back();
        base += "/EVE/hotreload";
    }
#endif
    if (base.empty()) base = ".";
    std::error_code ec;
    std::filesystem::create_directories(base, ec);
    hotDir_ = base;
    return hotDir_;
}
 
void HotReload::setRemoteHotDir(std::string dir) {
    if (syncStarted_) return;
    std::error_code ec;
    std::filesystem::create_directories(dir, ec);
    hotDir_ = std::move(dir);
}
 
bool HotReload::mountHotDir() {
    if (hotDirMounted_) return true;
    auto *fs = Filesystem::create();
    if (!fs) return false;
    const std::string dir = ensureHotDir();
    if (!fs->mountRealDirectory(dir, "/", /*appendToPath=*/false)) return false;
    hotDirMounted_ = true;
    return true;
}
 
bool HotReload::fetchManifest(std::vector<RemoteFile> &out) {
    const std::string url = stripTrailingSlash(syncUrl_) + "/manifest";
    const std::string body = httpGet(url, 2000);
    if (body.empty()) return false;
 
    try {
        Poco::JSON::Parser parser;
        Poco::Dynamic::Var result = parser.parse(body);
        Poco::JSON::Array::Ptr arr = result.extract<Poco::JSON::Array::Ptr>();
        if (!arr) return false;
        for (size_t i = 0; i < arr->size(); ++i) {
            Poco::JSON::Object::Ptr o = arr->getObject(static_cast<unsigned int>(i));
            if (!o) continue;
            RemoteFile f;
            f.path = o->optValue<std::string>("path", "");
            if (f.path.empty()) continue;
            f.size = o->optValue<int64_t>("size", -1);
            f.mtime = o->optValue<int64_t>("mtime", -1);
            f.path = normalizePath(std::move(f.path));
            if (!f.path.empty()) out.push_back(std::move(f));
        }
        return true;
    } catch (...) {
        return false;
    }
}
 
bool HotReload::downloadFile(const std::string &relPath) {
    const std::string url = stripTrailingSlash(syncUrl_) + "/raw/" + urlPathEscape(relPath);
    const std::string body = httpGet(url, 5000);
    if (body.empty()) return false;
    const std::string real = joinDir(ensureHotDir(), relPath);
    return writeFileBytes(real, body);
}
 
std::map<std::string, std::pair<int64_t, int64_t>> HotReload::loadRecord() const {
    std::map<std::string, std::pair<int64_t, int64_t>> record;
    const std::string real = joinDir(hotDir_, ".eve-manifest.json");
    std::ifstream ifs(real, std::ios::binary);
    if (!ifs) return record;
    std::ostringstream oss;
    oss << ifs.rdbuf();
    try {
        Poco::JSON::Parser parser;
        Poco::Dynamic::Var result = parser.parse(oss.str());
        Poco::JSON::Array::Ptr arr = result.extract<Poco::JSON::Array::Ptr>();
        if (!arr) return record;
        for (size_t i = 0; i < arr->size(); ++i) {
            Poco::JSON::Object::Ptr o = arr->getObject(static_cast<unsigned int>(i));
            if (!o) continue;
            const std::string path = o->optValue<std::string>("path", "");
            if (path.empty()) continue;
            record[path] = {o->optValue<int64_t>("size", -1), o->optValue<int64_t>("mtime", -1)};
        }
    } catch (...) {
    }
    return record;
}
 
void HotReload::saveRecord(const std::map<std::string, std::pair<int64_t, int64_t>> &record) const {
    Poco::JSON::Array::Ptr arr = new Poco::JSON::Array();
    for (const auto &kv : record) {
        Poco::JSON::Object::Ptr o = new Poco::JSON::Object();
        o->set("path", kv.first);
        o->set("size", kv.second.first);
        o->set("mtime", kv.second.second);
        arr->add(o);
    }
    std::ostringstream oss;
    Poco::JSON::Stringifier::stringify(arr, oss, 0, 0);
    const std::string real = joinDir(hotDir_, ".eve-manifest.json");
    writeFileBytes(real, oss.str());
}
 
void HotReload::queueChange(std::string path) {
    std::lock_guard<std::mutex> lock(syncMu_);
    changedQueue_.push_back(std::move(path));
}
 
void HotReload::applyManifest(const std::vector<RemoteFile> &manifest) {
    auto record = loadRecord();
    std::map<std::string, bool> seen;
    for (const auto &file : manifest) {
        seen[file.path] = true;
        auto it = record.find(file.path);
        if (it != record.end() && it->second.first == file.size && it->second.second == file.mtime)
            continue;  // unchanged
        if (downloadFile(file.path)) {
            record[file.path] = {file.size, file.mtime};
            queueChange(file.path);
        }
    }
    // Remove files that disappeared from the server.
    for (auto it = record.begin(); it != record.end();) {
        if (seen.find(it->first) != seen.end()) {
            ++it;
            continue;
        }
        const std::string real = joinDir(hotDir_, it->first);
        std::error_code ec;
        std::filesystem::remove(real, ec);
        queueChange(it->first);
        it = record.erase(it);
    }
    saveRecord(record);
}
 
void HotReload::syncLoop(int pollMs) {
    int failStreak = 0;
    while (syncRunning_.load()) {
        std::vector<RemoteFile> manifest;
        if (fetchManifest(manifest)) {
            failStreak = 0;
            {
                std::lock_guard<std::mutex> l(syncMu_);
                syncStatus_ = "syncing";
            }
            applyManifest(manifest);
            {
                std::lock_guard<std::mutex> l(syncMu_);
                syncStatus_ = "synced";
            }
        } else {
            ++failStreak;
            {
                std::lock_guard<std::mutex> l(syncMu_);
                syncStatus_ = failStreak > 3 ? "error:unreachable" : "idle";
            }
        }
 
        std::unique_lock<std::mutex> l(syncMu_);
        syncCv_.wait_for(l, std::chrono::milliseconds(pollMs), [this]() { return !syncRunning_.load(); });
    }
    {
        std::lock_guard<std::mutex> l(syncMu_);
        syncStatus_ = "idle";
    }
}
 
bool HotReload::startRemoteSync(std::string url, int pollMs) {
    std::lock_guard<std::mutex> lock(syncMu_);
    if (syncStarted_) return false;
    url = stripTrailingSlash(std::move(url));
    if (url.empty()) return false;
    if (url.rfind("http://", 0) != 0 && url.rfind("https://", 0) != 0) url = "http://" + url;
 
    syncUrl_ = std::move(url);
    syncStatus_ = "syncing";
    syncStarted_ = true;
    hotDirMounted_ = false;
    // Mount the overlay dir from the calling (main) thread; PhysFS mount is not
    // guaranteed thread-safe, so never touch it from the sync thread.
    if (!mountHotDir()) {
        syncStarted_ = false;
        syncStatus_ = "error:mount";
        return false;
    }
    syncRunning_.store(true);
    syncThread_ = std::thread([this, pollMs]() { syncLoop(pollMs); });
    return true;
}
 
void HotReload::stopRemoteSync() {
    {
        std::lock_guard<std::mutex> lock(syncMu_);
        if (!syncStarted_) return;
        syncRunning_.store(false);
    }
    syncCv_.notify_all();
    if (syncThread_.joinable()) syncThread_.join();
    std::lock_guard<std::mutex> lock(syncMu_);
    syncStarted_ = false;
    changedQueue_.clear();
}
 
bool HotReload::isRemoteSyncing() const { return syncRunning_.load(); }
 
std::string HotReload::remoteSyncStatus() const {
    std::lock_guard<std::mutex> lock(syncMu_);
    return syncStatus_;
}
 
std::string HotReload::pollRemoteChange() {
    std::lock_guard<std::mutex> lock(syncMu_);
    if (changedQueue_.empty()) return {};
    std::string p = std::move(changedQueue_.front());
    changedQueue_.pop_front();
    return p;
}
 
#endif  // !EVENGINE_WEBGPU
 
#ifdef EVENGINE_WEBGPU
// WebGPU (browser) build: no Poco HTTP client / threads for remote sync.
std::string HotReload::ensureHotDir() { return {}; }
bool HotReload::mountHotDir() { return false; }
bool HotReload::fetchManifest(std::vector<RemoteFile> &) { return false; }
bool HotReload::downloadFile(const std::string &) { return false; }
void HotReload::applyManifest(const std::vector<RemoteFile> &) {}
std::map<std::string, std::pair<int64_t, int64_t>> HotReload::loadRecord() const { return {}; }
void HotReload::saveRecord(const std::map<std::string, std::pair<int64_t, int64_t>> &) const {}
void HotReload::syncLoop(int) {}
void HotReload::queueChange(std::string) {}
bool HotReload::startRemoteSync(std::string, int) { return false; }
void HotReload::stopRemoteSync() {}
void HotReload::setRemoteHotDir(std::string) {}
bool HotReload::isRemoteSyncing() const { return false; }
std::string HotReload::remoteSyncStatus() const { return "idle"; }
std::string HotReload::pollRemoteChange() { return {}; }
#endif  // EVENGINE_WEBGPU
 
void HotReload::expose(ssq::Table &table) {
    auto cls = table.addClass(name, HotReload::create, false);
    expose(cls);
}
 
void HotReload::expose(ssq::Class &cls) {
    cls.addFunc("getName", &HotReload::getName);
    cls.addFunc("bind", &HotReload::bind);
    cls.addFunc("unbind", &HotReload::unbind);
    cls.addFunc("tryReload", &HotReload::tryReload);
    cls.addFunc("watchTree", &HotReload::watchTree);
    cls.addFunc("watchNewDirectory", &HotReload::watchNewDirectory);
    cls.addFunc("startRemoteSync", &HotReload::startRemoteSync);
    cls.addFunc("stopRemoteSync", &HotReload::stopRemoteSync);
    cls.addFunc("isRemoteSyncing", &HotReload::isRemoteSyncing);
    cls.addFunc("remoteSyncStatus", &HotReload::remoteSyncStatus);
    cls.addFunc("pollRemoteChange", &HotReload::pollRemoteChange);
}
 
}  // namespace eve::filesystem