derivations.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libstore/path.hh"
#include "lix/libutil/result.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/hash.hh"
#include "lix/libstore/content-address.hh"
#include "lix/libutil/repair-flag.hh"
#include "lix/libstore/derived-path-map.hh"
#include "lix/libutil/sync.hh"
#include "lix/libutil/comparator.hh"
#include "lix/libutil/variant-wrapper.hh"
 
#include <kj/async.h>
#include <map>
#include <variant>
 
 
namespace nix {
 
class Store;
 
/* Abstract syntax of derivations. */

struct DerivationOutput
{
    struct InputAddressed
    {
        StorePath path;
 
        GENERATE_CMP(InputAddressed, me->path);
    };

    struct CAFixed
    {
        ContentAddress ca;

        StorePath path(const Store & store, std::string_view drvName, OutputNameView outputName) const;
 
        GENERATE_CMP(CAFixed, me->ca);
    };

    struct CAFloating
    {
        ContentAddressMethod method;

        HashType hashType;
 
        GENERATE_CMP(CAFloating, me->method, me->hashType);
    };

    struct Deferred {
        GENERATE_CMP(Deferred);
    };

    struct Impure
    {
        ContentAddressMethod method;

        HashType hashType;
 
        GENERATE_CMP(Impure, me->method, me->hashType);
    };
 
    typedef std::variant<
        InputAddressed,
        CAFixed,
        CAFloating,
        Deferred,
        Impure
    > Raw;
 
    Raw raw;
 
    GENERATE_CMP(DerivationOutput, me->raw);
 
    MAKE_WRAPPER_CONSTRUCTOR(DerivationOutput);

    DerivationOutput() = delete;

    std::optional<StorePath> path(const Store & store, std::string_view drvName, OutputNameView outputName) const;
 
    JSON toJSON(
        const Store & store,
        std::string_view drvName,
        OutputNameView outputName) const;
    static DerivationOutput fromJSON(
        const Store & store,
        std::string_view drvName,
        OutputNameView outputName,
        const JSON & json,
        const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
};
 
typedef std::map<std::string, DerivationOutput> DerivationOutputs;

typedef std::map<std::string, std::pair<DerivationOutput, std::optional<StorePath>>>
  DerivationOutputsAndOptPaths;

typedef std::map<StorePath, StringSet> DerivationInputs;
 
struct DerivationType {
    struct InputAddressed {
        bool deferred;
 
        GENERATE_CMP(InputAddressed, me->deferred);
    };

    struct ContentAddressed {
        bool sandboxed;
        bool fixed;
 
        GENERATE_CMP(ContentAddressed, me->sandboxed, me->fixed);
    };

    struct Impure {
        GENERATE_CMP(Impure);
    };
 
    typedef std::variant<
        InputAddressed,
        ContentAddressed,
        Impure
    > Raw;
 
    Raw raw;
 
    GENERATE_CMP(DerivationType, me->raw);
 
    MAKE_WRAPPER_CONSTRUCTOR(DerivationType);

    DerivationType() = delete;

    bool isCA() const;

    bool isFixed() const;

    bool isSandboxed() const;

    bool isPure() const;

    bool hasKnownOutputPaths() const;
};
 
struct BasicDerivation
{
    DerivationOutputs outputs;
    StorePathSet inputSrcs;
    std::string platform;
    Path builder;
    Strings args;
    StringPairs env;
    std::string name;
 
    BasicDerivation() = default;
    virtual ~BasicDerivation() { };
 
    bool isBuiltin() const;

    DerivationType type() const;

    StringSet outputNames() const;

    DerivationOutputsAndOptPaths outputsAndOptPaths(const Store & store) const;
 
    static std::string_view nameFromPath(const StorePath & storePath);
 
    GENERATE_CMP(BasicDerivation,
        me->outputs,
        me->inputSrcs,
        me->platform,
        me->builder,
        me->args,
        me->env,
        me->name);
};
 
struct Derivation : BasicDerivation
{
    DerivedPathMap<std::set<OutputName>> inputDrvs;

    std::string unparse(const Store & store, bool maskOutputs,
        DerivedPathMap<StringSet>::ChildNode::Map * actualInputs = nullptr) const;

    kj::Promise<Result<std::optional<BasicDerivation>>>
    tryResolve(Store & store, Store * evalStore = nullptr) const;

    kj::Promise<Result<std::optional<BasicDerivation>>> tryResolve(
        Store & store,
        const std::map<std::pair<StorePath, std::string>, StorePath> & inputDrvOutputs) const;

    kj::Promise<Result<void>> checkInvariants(Store & store, const StorePath & drvPath) const;
 
    Derivation() = default;
    Derivation(const BasicDerivation & bd) : BasicDerivation(bd) { }
    Derivation(BasicDerivation && bd) : BasicDerivation(std::move(bd)) { }
 
    JSON toJSON(const Store & store) const;
    static Derivation fromJSON(
        const Store & store,
        const JSON & json,
        const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
 
    GENERATE_CMP(Derivation,
        static_cast<const BasicDerivation &>(*me),
        me->inputDrvs);
};
 
 
class Store;

kj::Promise<Result<StorePath>> writeDerivation(Store & store,
    const Derivation & drv,
    RepairFlag repair = NoRepair,
    bool readOnly = false);

Derivation parseDerivation(
    const Store & store,
    std::string && s,
    std::string_view name,
    const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);

bool isDerivation(std::string_view fileName);

std::string outputPathName(std::string_view drvName, OutputNameView outputName);
 

struct DrvHash {
    std::map<std::string, Hash> hashes;
 
    enum struct Kind : bool {
        Regular,

        Deferred,
    };

    Kind kind;
};
 
void operator |= (DrvHash::Kind & self, const DrvHash::Kind & other) noexcept;

kj::Promise<Result<DrvHash>>
hashDerivationModulo(Store & store, const Derivation & drv, bool maskOutputs);

kj::Promise<Result<std::map<std::string, Hash>>>
staticOutputHashes(Store & store, const Derivation & drv);

typedef std::map<StorePath, DrvHash> DrvHashes;
 
// FIXME: global, though at least thread-safe.
extern Sync<DrvHashes> drvHashes;
 
struct Source;
struct Sink;
 
Source & readDerivation(Source & in, const Store & store, BasicDerivation & drv, std::string_view name);
void writeDerivation(Sink & out, const Store & store, const BasicDerivation & drv);

std::string hashPlaceholder(const OutputNameView outputName);
 
extern const Hash impureOutputHash;
 
}