Function SweepNamespaceSchemas

src/platform/linux/schema_fetch.cpp:567–611

Proactive sweep.

// Proactive sweep.
static void SweepNamespaceSchemas() {
    if (!MetadataSync::SchemaFetchEnabled()) return;
    if (g_connHandle.load(std::memory_order_relaxed) == 0) return;

    auto apps = CloudIntercept::GetNamespaceApps();
    if (apps.empty()) return;

    LOG("[SchemaFetch] Proactive sweep: checking %zu namespace app(s)", apps.size());

    std::string steamPath = CloudIntercept::GetSteamPath();
    std::vector<uint32_t> needed;
    for (uint32_t appId : apps) {
        std::string path = steamPath + "appcache/stats/UserGameStatsSchema_"
            + std::to_string(appId) + ".bin";
        struct stat st;
        if (stat(path.c_str(), &st) != 0 || st.st_size == 0) {
            needed.push_back(appId);
        }
    }
    if (needed.empty()) {
        LOG("[SchemaFetch] All schemas present on disk");
        return;
    }

    LOG("[SchemaFetch] %zu app(s) need schemas, fetching with 4 workers", needed.size());

    constexpr int kWorkers = 4;
    std::atomic<size_t> idx{0};
    std::atomic<int> totalRequested{0};
    std::vector<std::thread> workers;
    for (int w = 0; w < kWorkers; ++w) {
        workers.emplace_back([&needed, &idx, &totalRequested] {
            while (true) {
                if (g_shuttingDown.load(std::memory_order_acquire)) break;
                size_t i = idx.fetch_add(1, std::memory_order_relaxed);
                if (i >= needed.size()) break;
                RequestSchemaForApp(needed[i]);
                totalRequested.fetch_add(1, std::memory_order_relaxed);
            }
        });
    }
    for (auto& t : workers) t.join();
    LOG("[SchemaFetch] Sweep complete: enqueued schemas for %d app(s)",
        totalRequested.load(std::memory_order_relaxed));
}

static void MaybeScheduleSweep() {
    if (!MetadataSync::SchemaFetchEnabled()) return;