project_package.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/project_package/atomic_publisher.hpp>
#include <pulp/timeline/assets.hpp>
#include <pulp/timeline/model.hpp>
#include <pulp/timeline/schema_registry.hpp>
 
#include <cstdint>
#include <filesystem>
#include <memory>
#include <span>
#include <vector>
 
namespace pulp::project_package {

enum class BlobStore : std::uint8_t { Media, State, Artifact, Receipt };

struct BlobReference {
    BlobStore store = BlobStore::Media;
    timeline::ContentHash hash;
    constexpr auto operator<=>(const BlobReference&) const = default;
};

struct PackageLimits {
    std::uint64_t max_blob_bytes = 8ull * 1024ull * 1024ull * 1024ull;
    std::uint64_t max_project_bytes = 64ull * 1024ull * 1024ull;
};

struct OpenPackageResult {
    timeline::Project project;
    std::filesystem::path journal_directory;
    std::filesystem::path cache_directory;
    bool cache_recreated = false;
};

class PackageWriter {
  public:
    static runtime::Result<PackageWriter, PackageError>
    create(const std::filesystem::path& root, timeline::SchemaRegistry registry,
           const PackageLimits& limits = {}) noexcept;
 
    ~PackageWriter();
    PackageWriter(PackageWriter&&) noexcept;
    PackageWriter& operator=(PackageWriter&&) noexcept;
    PackageWriter(const PackageWriter&) = delete;
    PackageWriter& operator=(const PackageWriter&) = delete;

    const std::filesystem::path& root() const noexcept;
    bool recovered_staging() const noexcept;

    runtime::Result<BlobReference, PackageError>
    stage_blob(BlobStore store, const timeline::ContentHash& expected,
               std::span<const std::uint8_t> bytes) noexcept;
    runtime::Result<AtomicPublishOutcome, PackageError>
    publish(const timeline::Project& project) noexcept;
 
  private:
    struct Impl;
    explicit PackageWriter(std::unique_ptr<Impl> impl) noexcept;
    std::unique_ptr<Impl> impl_;
};

runtime::Result<OpenPackageResult, PackageError>
open_package(const std::filesystem::path& root, const timeline::SchemaRegistry& registry,
             const PackageLimits& limits = {}) noexcept;

runtime::Result<std::vector<std::uint8_t>, PackageError>
read_blob(const std::filesystem::path& root, const BlobReference& reference,
          std::uint64_t maximum_bytes) noexcept;
 
} // namespace pulp::project_package