id_pair_scratch_file.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/detail/scratch_file.hpp>
 
#include <algorithm>
#include <cerrno>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string>
#include <system_error>
#include <utility>
 
namespace pineforge::detail {
 
// Keep L19a's system_error surface, carrying the run's resource failure too.
class IdPairStoreError final : public std::system_error, public RunFailureInfo {
public:
    IdPairStoreError(int error, const char* operation)
        : std::system_error(error, std::generic_category(), operation),
          RunFailureInfo(RunFailureCode::scratch_io_failed, {}) {}
};
 
class IdPairScratchFile {
public:
    // Explicit per-instance fixture seam. Counters observe actual transfers
    // (syscalls in file mode, checked copies in arena mode);
    // a selected write writes a real prefix, then reports an IO failure.
    struct FixtureIO {
        std::uint64_t reads = 0, writes = 0;
        std::uint64_t read_bytes = 0, write_bytes = 0;
        std::uint64_t fail_write = 0;
        std::size_t partial_write = 0;
    };
    void fixture_count_io(FixtureIO* io) noexcept { fixture_io_ = io; }
    FixtureIO* fixture_io() const noexcept { return fixture_io_; }
    void set_store(ScratchStore store) noexcept { file_.set_store(store); }
 
    explicit IdPairScratchFile(ScratchStore store = ScratchStore::unknown) {
        file_.set_store(store);
    }
    IdPairScratchFile(const IdPairScratchFile&) = delete;
    IdPairScratchFile& operator=(const IdPairScratchFile&) = delete;
    IdPairScratchFile(IdPairScratchFile&& other) noexcept
        : file_(std::move(other.file_)),
          fixture_io_(std::exchange(other.fixture_io_, nullptr)) {}
    IdPairScratchFile& operator=(IdPairScratchFile&& other) noexcept {
        if (this != &other) {
            reset();
            file_ = std::move(other.file_);
            fixture_io_ = std::exchange(other.fixture_io_, nullptr);
        }
        return *this;
    }
    ~IdPairScratchFile() = default;
 
    bool opened() const noexcept { return file_.opened(); }
    bool disk_backed() const noexcept { return file_.disk_backed(); }
    void reset() noexcept { file_.clear(); }
    void open(const std::string& directory) {
        if (opened()) return;
        file_.set_directory(directory);
        auxiliary("id table create", [&] { file_.open("pineforge-id-pairs"); });
    }
    void resize(std::uint64_t bytes) {
        check_range(0, bytes);
        if (!opened()) throw IdPairStoreError(EBADF, "id table resize");
        // The production sizing caller owns a fresh replacement index.
        // Monotone zero-filled growth also works without a sizing syscall.
        auxiliary("id table resize", [&] { file_.ensure_size(bytes); });
    }
    void read(std::uint64_t offset, void* destination, std::size_t length) const {
        check_range(offset, length);
        auto* bytes = static_cast<unsigned char*>(destination);
        std::size_t received = 0;
        while (received < length) {
            if (fixture_io_) ++fixture_io_->reads;
            const ssize_t count = auxiliary("id table read", [&] {
                return file_.read_some(offset + received, bytes + received, length - received);
            });
            if (count < 0 && errno == EINTR) continue;
            if (count <= 0)
                throw IdPairStoreError(count < 0 ? errno : EIO, "id table read");
            if (fixture_io_) fixture_io_->read_bytes += static_cast<std::uint64_t>(count);
            received += static_cast<std::size_t>(count);
        }
    }
    void write(std::uint64_t offset, const void* source, std::size_t length) {
        check_range(offset, length);
        const auto* bytes = static_cast<const unsigned char*>(source);
        std::size_t written = 0;
        while (written < length) {
            if (fixture_io_ && ++fixture_io_->writes == fixture_io_->fail_write) {
                const auto prefix = std::min(fixture_io_->partial_write, length - written);
                if (prefix != 0) {
                    const auto count = auxiliary("id table fixture short write", [&] {
                        return file_.write_some(offset + written, bytes + written, prefix);
                    });
                    if (count > 0) fixture_io_->write_bytes += static_cast<std::uint64_t>(count);
                }
                throw IdPairStoreError(EIO, "id table fixture short write");
            }
            const ssize_t count = auxiliary("id table write", [&] {
                return file_.write_some(offset + written, bytes + written, length - written);
            });
            if (count < 0 && errno == EINTR) continue;
            if (count <= 0)
                throw IdPairStoreError(count < 0 ? errno : EIO, "id table write");
            if (fixture_io_) fixture_io_->write_bytes += static_cast<std::uint64_t>(count);
            written += static_cast<std::size_t>(count);
        }
    }
 
private:
    template<class Operation>
    static auto auxiliary(const char* operation, Operation transfer) -> decltype(transfer()) {
        try { return transfer(); }
        catch (const AuxiliaryScratchIoError& error) {
            throw IdPairStoreError(error.code().value(), scratch_with_detail(operation, error.what(), error.code().value()).c_str());
        }
        // Arena backing/capacity failures retain their report-scratch type
        // and payload. Only auxiliary I/O becomes the historical ID error.
    }
    static void check_range(std::uint64_t offset, std::uint64_t length) {
        constexpr auto maximum = static_cast<std::uint64_t>(std::numeric_limits<off_t>::max());
        if (offset > maximum || length > maximum - offset)
            throw IdPairStoreError(EFBIG, "id table offset exhausted");
    }
    ScratchFile file_{ScratchFile::IoRaiser::auxiliary};
    FixtureIO* fixture_io_ = nullptr;
};
 
} // namespace pineforge::detail