model_download.hpp

Go to the documentation of this file.

#pragma once
 
// Streaming HTTPS file downloader for the model manager. Unlike
// runtime/http.hpp's http_download (whole-body, in-memory — fine for small JSON,
// fatal for GB-scale weights), this streams the body incrementally to disk with a
// progress callback, HTTP Range **resume**, request **headers** (e.g. HuggingFace
// auth), **cancellation**, **sha256** verification, and a temp-stage → atomic-rename
// so a partial/aborted transfer never appears as a finished file. HTTPS rides on
// cpp-httplib's mbedTLS backend (mbedTLS is already linked by core/runtime).
 
#include <cstdint>
#include <filesystem>
#include <functional>
#include <string>
#include <vector>
 
namespace pulp::runtime {
 
class CancelToken; // cancel.hpp
 
struct DownloadProgress {
    std::uint64_t downloaded = 0;  
    std::uint64_t total = 0;       
};
 
struct HttpHeader {
    std::string name;
    std::string value;
};
 
struct DownloadRequest {
    std::string url;                       
    std::filesystem::path dest;            
    std::string expected_sha256;           
    std::vector<HttpHeader> headers;       
    bool resume = true;                    
    int timeout_seconds = 0;               
    bool allow_unverified = false;
};

inline int download_connect_timeout_seconds(int request_timeout_seconds) {
    constexpr int kConnectTimeoutSeconds = 15;
    return request_timeout_seconds > 0
               ? (request_timeout_seconds < kConnectTimeoutSeconds
                      ? request_timeout_seconds
                      : kConnectTimeoutSeconds)
               : kConnectTimeoutSeconds;
}
 
struct DownloadResult {
    bool ok = false;
    std::string error;
    std::filesystem::path path;            
    std::uint64_t bytes = 0;               
    std::string sha256;                    
    bool resumed = false;                  
    bool cancelled = false;                
    bool unverified = false;
};

struct ResolvedRedirect {
    std::string scheme_host_port; 
    std::string path;             
    bool ok = false;              
    std::string error;
};

ResolvedRedirect resolve_redirect(const std::string& current_scheme_host_port,
                                  const std::string& current_path, const std::string& location);

using DownloadProgressFn = std::function<bool(const DownloadProgress&)>;

DownloadResult download_file(const DownloadRequest& request,
                             const DownloadProgressFn& on_progress = {},
                             const CancelToken* cancel = nullptr);
 
}  // namespace pulp::runtime