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 tmpDirRoot, tmpDir;

    AutoCloseFD tmpDirRootFd, tmpDirFd;

    Path tmpDirInSandbox;

    AutoCloseFD builderOutPTY;

    Pipe userNamespaceSync;

    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;

    std::vector<std::thread> daemonWorkerThreads;

    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 chownToBuilder(const Path & path);

    void chownToBuilder(const AutoCloseFD & fd);
 
    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 finalizeTmpDir(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;

    bool runPasta = false;

    virtual void prepareSandbox()
    {
        throw Error("sandboxing builds is not supported on this platform");
    };

    virtual std::string rewriteResolvConf(std::string fromHost)
    {
        return fromHost;
    }

    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;
    }
};
 
}