1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

#pragma once
///@file

#include "lix/libexpr/eval.hh"
#include "lix/libstore/derivations.hh"
#include "lix/libstore/path.hh"

#include <string>
#include <map>


namespace nix {


struct DrvInfo
{
public:
    typedef std::map<std::string, std::optional<StorePath>> Outputs;

private:
    std::string name;
    std::string system;
    std::optional<std::optional<StorePath>> drvPath;
    std::optional<StorePath> outPath;
    std::string outputName;
    Outputs outputs;

    /**
     * Set if we get an AssertionError
     */
    bool failed = false;

    Bindings * attrs = nullptr, * meta = nullptr;

    Bindings * getMeta(EvalState & state);

    bool checkMeta(EvalState & state, Value & v);

    void fillOutputs(EvalState & state, bool withPaths = true);

    DrvInfo(
        ref<Store> store,
        const std::string & drvPathWithOutputs,
        Derivation drv,
        const StorePath & drvPath,
        const std::set<std::string> & selectedOutputs
    );

public:
    /**
     * path towards the derivation
     */
    std::string attrPath;

    DrvInfo(std::string attrPath, Bindings * attrs);
    static kj::Promise<Result<DrvInfo>>
    create(ref<Store> store, const std::string & drvPathWithOutputs);

    std::string queryName(EvalState & state);
    std::string querySystem(EvalState & state);
    std::optional<StorePath> queryDrvPath(EvalState & state);
    StorePath requireDrvPath(EvalState & state);
    StorePath queryOutPath(EvalState & state);
    std::string queryOutputName(EvalState & state);
    /**
     * Return the unordered map of output names to (optional) output paths.
     * The "outputs to install" are determined by `meta.outputsToInstall`.
     */
    Outputs queryOutputs(EvalState & state, bool withPaths = true, bool onlyOutputsToInstall = false);

    StringSet queryMetaNames(EvalState & state);
    Value * queryMeta(EvalState & state, const std::string & name);
    std::string queryMetaString(EvalState & state, const std::string & name);
    NixInt queryMetaInt(EvalState & state, const std::string & name, NixInt def);
    bool queryMetaBool(EvalState & state, const std::string & name, bool def);
    void setMeta(EvalState & state, const std::string & name, Value & v);

    /*
    MetaInfo queryMetaInfo(EvalState & state) const;
    MetaValue queryMetaInfo(EvalState & state, const string & name) const;
    */

    void setName(const std::string & s) { name = s; }
    void setDrvPath(StorePath path) { drvPath = {{std::move(path)}}; }
    void setOutPath(StorePath path) { outPath = {{std::move(path)}}; }

    void setFailed() { failed = true; };
    bool hasFailed() { return failed; };
};

using DrvInfos = GcList<DrvInfo>;

/**
 * If value `v` denotes a derivation, return a DrvInfo object
 * describing it. Otherwise return nothing.
 */
std::optional<DrvInfo> getDerivation(EvalState & state,
    Value & v, bool ignoreAssertionFailures);

void getDerivations(EvalState & state, Value & v, const std::string & pathPrefix,
    Bindings & autoArgs, DrvInfos & drvs,
    bool ignoreAssertionFailures);


}