Function LoadRootTokens

src/common/local_metadata_store.cpp:102–151

}

std::unordered_set<std::string> LoadRootTokens(uint32_t accountId, uint32_t appId) {
    std::unordered_set<std::string> tokens;
    bool needsRewrite = false;
    bool fromLegacy = false;

    // Read phase: shared lock allows concurrent readers
    {
        std::shared_lock<std::shared_mutex> lock(g_metadataMutex);
        std::string appPath = GetAppPathInternal(accountId, appId);
        std::string path = appPath + kRootTokenFilename;
        std::string legacyPath = appPath + kLegacyRootTokenFilename;

        std::ifstream f(FileUtil::Utf8ToPath(path));
        if (!f) {
            f.open(FileUtil::Utf8ToPath(legacyPath));
            if (f) fromLegacy = true;
        }
        if (f) {
            std::string line;
            while (std::getline(f, line)) {
                std::string original = line;
                while (!line.empty() && (line.back() == '\r' || line.back() == '\n'))
                    line.pop_back();
                if (line != original)
                    needsRewrite = true;
                if (!line.empty()) {
                    tokens.insert(line);
                }
            }
            f.close();
            if (!tokens.empty()) {
                LOG("LoadRootTokens: loaded %zu tokens from %s for app %u",
                    tokens.size(), fromLegacy ? "legacy path" : "disk", appId);
            }
        }
    }

    // Migrate from legacy or rewrite if corrupted.
        // Skip if canonical file already exists.
    if ((fromLegacy || needsRewrite) && !tokens.empty()) {
        if (fromLegacy) {
            LOG("LoadRootTokens: migrating tokens for app %u", appId);
        } else {
            LOG("LoadRootTokens: cleaning corrupted tokens for app %u", appId);
        }
        (void)SaveRootTokens(accountId, appId, tokens);
    }

    return tokens;
}

bool SaveFileTokens(uint32_t accountId, uint32_t appId,
                    const std::unordered_map<std::string, std::string>& fileTokens,