Method getArchiveForModule

valdi/src/valdi/runtime/Resources/ResourceManager.cpp:80–151

}

static StringBox resolveSourceMapFilePath(const StringBox& modulePath) {
    return modulePath.append(".map.json");
}

static int32_t parseApiVersion(const BytesView& bytes, ILogger& logger) {
    TextParser parser(std::string_view(reinterpret_cast<const char*>(bytes.data()), bytes.size()));

    parser.tryParseWhitespaces();
    auto version = parser.parseUInt();
    parser.tryParseWhitespaces();

    if (!version.has_value() || !parser.isAtEnd() || version.value() > std::numeric_limits<int32_t>::max()) {
        VALDI_WARN(logger, "Invalid valdi_api_version resource content. Expected a non-negative integer.");
        return 0;
    }

    return static_cast<int32_t>(version.value());
}

int32_t ResourceManager::getApiVersion() {
    {
        std::lock_guard<Mutex> guard(_mutex);
        if (_apiVersion.has_value()) {
            return _apiVersion.value();
        }
    }

    // Loaded outside _mutex: the resource loader crosses into the platform and on the first call can
    // initialize the Dynamic Delivery archive, which waits on the content manager. Holding _mutex
    // across it blocked the main thread in preloadForComponentPath for 10s+ (MUSIC-13144,
    // SHARING-35215). Concurrent first callers may both reach the loader; the Dynamic Delivery
    // archive init behind it is a std::call_once, so the heavy work still runs once.
    auto content = _resourceLoader->loadModuleContent(STRING_LITERAL("valdi_api_version"));
    int32_t apiVersion = content ? parseApiVersion(content.value(), _logger) : 0;

    std::lock_guard<Mutex> guard(_mutex);
    if (!_apiVersion.has_value()) {
        _apiVersion = apiVersion;
    }
    return _apiVersion.value();
}

Result<Ref<ValdiModuleArchive>> ResourceManager::getArchiveForModule(const StringBox& modulePath,
                                                                     bool useMmap,
                                                                     const Path& mmapCacheDir,
                                                                     const Ref<Metrics>& metrics) {
    auto bundleFilePath = resolveModuleArchiveFilePath(modulePath);

    auto bundleContent = _resourceLoader->loadModuleContent(bundleFilePath);
    if (!bundleContent) {
        // Fallback on .valdimodule for backward compatibility
        auto bundleContentAlternative = _resourceLoader->loadModuleContent(modulePath.append(".valdimodule"));
        if (!bundleContentAlternative) {
            return bundleContent.error().rethrow(STRING_FORMAT("Unable to load module '{}'", modulePath));
        } else {
            bundleContent = std::move(bundleContentAlternative);
        }
    }