content_install_limits.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <cstdint>
#include <string>
#include <string_view>
 
namespace pulp::state {

struct ContentInstallLimits {
    std::uint64_t max_total_bytes = std::uint64_t{4} << 30; 
    std::uint64_t max_entry_bytes = std::uint64_t{1} << 30; 
    std::uint64_t max_entries = 65536;
};

inline ContentInstallLimits clamp_content_install_bytes(ContentInstallLimits limits,
                                                        std::uint64_t max_bytes) {
    limits.max_total_bytes = std::min(limits.max_total_bytes, max_bytes);
    limits.max_entry_bytes = std::min(limits.max_entry_bytes, max_bytes);
    return limits;
}

class ContentSizeBudget {
  public:
    explicit ContentSizeBudget(ContentInstallLimits limits = {}) : limits_(limits) {}

    std::string admit(std::string_view entry_name, std::uint64_t bytes) {
        if (entries_ >= limits_.max_entries) {
            return "archive-size: entry `" + std::string(entry_name) + "` is entry " +
                   std::to_string(entries_ + 1) + ", above the entry-count cap of " +
                   std::to_string(limits_.max_entries) + " entries";
        }
        if (bytes > limits_.max_entry_bytes) {
            return "archive-size: entry `" + std::string(entry_name) + "` declares " +
                   std::to_string(bytes) + " bytes, above the per-entry cap of " +
                   std::to_string(limits_.max_entry_bytes) + " bytes";
        }
        if (bytes > limits_.max_total_bytes - total_) {
            return "archive-size: entry `" + std::string(entry_name) +
                   "` would bring the pack to " + std::to_string(total_ + bytes) +
                   " bytes, above the total cap of " + std::to_string(limits_.max_total_bytes) +
                   " bytes";
        }
        total_ += bytes;
        ++entries_;
        return {};
    }
 
    std::uint64_t admitted_bytes() const {
        return total_;
    }
    std::uint64_t admitted_entries() const {
        return entries_;
    }
    const ContentInstallLimits& limits() const {
        return limits_;
    }
 
  private:
    ContentInstallLimits limits_;
    std::uint64_t total_ = 0;
    std::uint64_t entries_ = 0;
};
 
} // namespace pulp::state