realisation.hh

Go to the documentation of this file.

#pragma once
 
#include <variant>
 
#include "lix/libutil/hash.hh"
#include "lix/libutil/json-fwd.hh"
#include "lix/libstore/path.hh"
#include "lix/libstore/derived-path.hh"
#include "lix/libutil/comparator.hh"
#include "lix/libstore/crypto.hh"
 
namespace nix {
 
class Store;
struct OutputsSpec;

struct DrvOutput {
    Hash drvHash;

    OutputName outputName;
 
    std::string to_string() const;
 
    std::string strHash() const
    { return drvHash.to_string(Base::Base16, true); }
 
    static DrvOutput parse(const std::string &);
 
    GENERATE_CMP(DrvOutput, me->drvHash, me->outputName);
};
 
struct Realisation {
    DrvOutput id;
    StorePath outPath;
 
    StringSet signatures = {};

    std::map<DrvOutput, StorePath> dependentRealisations = {};
 
    JSON toJSON() const;
    static Realisation fromJSON(const JSON& json, const std::string& whence);
 
    std::string fingerprint() const;
    void sign(const SecretKey &);
    bool checkSignature(const PublicKeys & publicKeys, const std::string & sig) const;
    size_t checkSignatures(const PublicKeys & publicKeys) const;
 
    static kj::Promise<Result<std::set<Realisation>>>
    closure(Store &, const std::set<Realisation> &);
    static kj::Promise<Result<void>>
    closure(Store &, const std::set<Realisation> &, std::set<Realisation> & res);
 
    bool isCompatibleWith(const Realisation & other) const;
 
    StorePath getPath() const { return outPath; }
 
    GENERATE_CMP(Realisation, me->id, me->outPath);
};

typedef std::map<OutputName, Realisation> SingleDrvOutputs;

typedef std::map<DrvOutput, Realisation> DrvOutputs;

SingleDrvOutputs filterDrvOutputs(const OutputsSpec&, SingleDrvOutputs&&);
 
 
struct OpaquePath {
    StorePath path;
 
    StorePath getPath() const { return path; }
 
    GENERATE_CMP(OpaquePath, me->path);
};
 

struct RealisedPath {
    /*
     * A path is either the result of the realisation of a derivation or
     * an opaque blob that has been directly added to the store
     */
    using Raw = std::variant<Realisation, OpaquePath>;
    Raw raw;
 
    using Set = std::set<RealisedPath>;
 
    RealisedPath(StorePath path) : raw(OpaquePath{path}) {}
    RealisedPath(Realisation r) : raw(r) {}

    StorePath path() const;
 
    kj::Promise<Result<void>> closure(Store & store, Set & ret) const;
    static kj::Promise<Result<void>> closure(Store & store, const Set & startPaths, Set & ret);
    kj::Promise<Result<Set>> closure(Store & store) const;
 
    GENERATE_CMP(RealisedPath, me->raw);
};
 
class MissingRealisation : public Error
{
public:
    MissingRealisation(DrvOutput & outputId)
        : MissingRealisation(outputId.outputName, outputId.strHash())
    {}
    MissingRealisation(std::string_view drv, OutputName outputName)
        : Error( "cannot operate on output '%s' of the "
                "unbuilt derivation '%s'",
                outputName,
                drv)
    {}
};
 
}