local-derivation-goal.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libstore/build/derivation-goal.hh"
#include "lix/libstore/local-store.hh"
#include "lix/libutil/processes.hh"
 
namespace nix {
 
struct LocalDerivationGoal : public DerivationGoal
{
    LocalStore & getLocalStore();
 
    std::unique_ptr<UserLock> buildUser;
 
    Pid pid;
 
    std::optional<Path> cgroup;
 
    Path tmpDir;
 
    Path tmpDirInSandbox;
 
    AutoCloseFD builderOutPTY;
 
    Pipe userNamespaceSync;
 
    AutoCloseFD sandboxMountNamespace;
    AutoCloseFD sandboxUserNamespace;
 
    bool usingUserNamespace = true;
 
    bool useChroot = false;
 
    Path chrootRootDir;
 
    std::shared_ptr<AutoDelete> autoDelChroot;
 
    bool privateNetwork = false;
 
    struct ChrootPath {
        Path source;
        bool optional;
        ChrootPath(Path source = "", bool optional = false)
            : source(source), optional(optional)
        { }
    };
    typedef map<Path, ChrootPath> PathsInChroot; // maps target path to source path
    PathsInChroot pathsInChroot;
 
    typedef map<std::string, std::string> Environment;
    Environment env;
 
#if __APPLE__
    typedef std::string SandboxProfile;
    SandboxProfile additionalSandboxProfile;
#endif
 
    StringMap inputRewrites, outputRewrites;
    typedef map<StorePath, StorePath> RedirectedOutputs;
    RedirectedOutputs redirectedOutputs;
 
    OutputPathMap scratchOutputs;
 
    std::map<Path, ValidPathInfo> prevInfos;
 
    uid_t sandboxUid() { return usingUserNamespace ? (!buildUser || buildUser->getUIDCount() == 1 ? 1000 : 0) : buildUser->getUID(); }
    gid_t sandboxGid() { return usingUserNamespace ? (!buildUser || buildUser->getUIDCount() == 1 ? 100  : 0) : buildUser->getGID(); }
 
    const static Path homeDir;
 
    AutoCloseFD daemonSocket;
 
    std::thread daemonThread;
 
    std::vector<std::thread> daemonWorkerThreads;
 
    StorePathSet addedPaths;
 
    std::set<DrvOutput> addedDrvOutputs;
 
    bool isAllowed(const StorePath & path)
    {
        return inputPaths.count(path) || addedPaths.count(path);
    }
    bool isAllowed(const DrvOutput & id)
    {
        return addedDrvOutputs.count(id);
    }
 
    bool isAllowed(const DerivedPath & req);
 
    friend struct RestrictedStore;
 
    static std::unique_ptr<LocalDerivationGoal> makeLocalDerivationGoal(
        const StorePath & drvPath,
        const OutputsSpec & wantedOutputs,
        Worker & worker,
        bool isDependency,
        BuildMode buildMode
    );
 
    static std::unique_ptr<LocalDerivationGoal> makeLocalDerivationGoal(
        DrvHasRoot drvRoot,
        const StorePath & drvPath,
        const BasicDerivation & drv,
        const OutputsSpec & wantedOutputs,
        Worker & worker,
        bool isDependency,
        BuildMode buildMode
    );
 
    virtual ~LocalDerivationGoal() noexcept(false) override;
 
   virtual bool needsHashRewrite();
 
    kj::Promise<Result<WorkResult>> tryLocalBuild() noexcept override;
 
    kj::Promise<Result<void>> startBuilder();
 
    void initEnv();
 
    void initTmpDir();
 
    kj::Promise<Result<void>> writeStructuredAttrs();
 
    void startDaemon();
 
    void stopDaemon();
 
    void addDependency(const StorePath & path);
 
    void chownToBuilder(const Path & path);
 
    int getChildStatus() override;
 
    void runChild();
 
    kj::Promise<Result<SingleDrvOutputs>> registerOutputs() override;
 
    void signRealisation(Realisation &) override;
 
    kj::Promise<Result<void>> checkOutputs(const std::map<std::string, ValidPathInfo> & outputs, const std::map<std::string, StorePath> & alreadyRegisteredOutputs);
 
    void closeReadPipes() override;
 
    void cleanupHookFinally() override;
    void cleanupPreChildKill() override;
    void cleanupPostChildKill() override;
    bool cleanupDecideWhetherDiskFull() override;
    void cleanupPostOutputsRegisteredModeCheck() override;
    void cleanupPostOutputsRegisteredModeNonCheck() override;
 
    void deleteTmpDir(bool force, bool duringDestruction = false);
 
    void killChild() override final;
 
    virtual void killSandbox(bool getStats);
 
    StorePath makeFallbackPath(const StorePath & path);
 
    StorePath makeFallbackPath(OutputNameView outputName);
 
protected:
    using DerivationGoal::DerivationGoal;
 
    virtual void prepareSandbox()
    {
        throw Error("sandboxing builds is not supported on this platform");
    };
 
    virtual Pid startChild(std::function<void()> openSlave);
 
    virtual void setupSyscallFilter() {}
 
    virtual void execBuilder(std::string builder, Strings args, Strings envStrs);
 
    virtual bool supportsUidRange()
    {
        return false;
    }
 
    virtual bool respectsTimeouts() override
    {
        return true;
    }
};
 
}