archive.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/async-io.hh"
#include "lix/libutil/box_ptr.hh"
#include "lix/libutil/generator.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/serialise.hh"
#include "lix/libutil/file-system.hh"
 
 
namespace nix {
 
 
WireFormatGenerator dumpPath(Path path, PathFilter & filter);
WireFormatGenerator dumpPath(Path path);
 
WireFormatGenerator dumpPathAndGetMtime(Path path, time_t & mtime);
 
struct PreparedDump
{
    const Path rootPath;
 
    explicit PreparedDump(Path rootPath) : rootPath(std::move(rootPath)) {}
 
    virtual ~PreparedDump() = default;
 
    virtual WireFormatGenerator dump() const = 0;
};
 
box_ptr<PreparedDump> prepareDump(Path path);
box_ptr<PreparedDump> prepareDump(Path path, PathFilter & filter);
 
WireFormatGenerator dumpString(std::string_view s);
 
struct NARParseVisitor
{
    struct FileHandle
    {
        FileHandle() {}
        FileHandle(FileHandle const &) = delete;
        FileHandle & operator=(FileHandle &) = delete;
 
        virtual void receiveContents(std::string_view data) = 0;
 
        virtual void close() = 0;
 
        virtual ~FileHandle() = default;
    };
 
    virtual ~NARParseVisitor() = default;
 
    virtual box_ptr<NARParseVisitor> createDirectory(const std::string & name) = 0;
 
    virtual box_ptr<FileHandle> createRegularFile(const std::string & name, uint64_t size, bool executable) = 0;
 
    virtual void createSymlink(const std::string & name, const std::string & target) = 0;
};
 
namespace nar {
 
struct File;
struct Symlink;
struct Directory;
using Entry = std::variant<File, Symlink, Directory>;
 
struct File
{
    bool executable;
    uint64_t size;
    Generator<Bytes> contents;
};
 
struct Symlink
{
    Path target;
};
 
struct Directory
{
    Generator<std::pair<const std::string &, Entry>> contents;
};
 
WireFormatGenerator dump(Entry nar);
 
Generator<Entry> parse(Source & source);
}
 
namespace nar_index {
 
struct File;
struct Symlink;
struct Directory;
using Entry = std::variant<File, Symlink, Directory>;
 
struct File
{
    bool executable;
    uint64_t offset, size;
};
 
struct Symlink
{
    Path target;
};
 
struct Directory
{
    std::map<std::string, Entry> contents;
};
 
Entry create(Source & source);
kj::Promise<Result<Entry>> create(AsyncInputStream & source);
 
}
 
void parseDump(NARParseVisitor & sink, Source & source);
kj::Promise<Result<void>> parseDump(NARParseVisitor & sink, AsyncInputStream & source);
 
void restorePath(const Path & path, Source & source);
kj::Promise<Result<void>> restorePath(const Path & path, AsyncInputStream & source);
 
WireFormatGenerator copyNAR(Source & source);
box_ptr<AsyncInputStream> copyNAR(AsyncInputStream & source);
 
 
inline constexpr std::string_view narVersionMagic1 = "nix-archive-1";
 
inline constexpr std::string_view caseHackSuffix = "~nix~case~hack~";
 
 
}