derivation-goal.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/notifying-counter.hh"
#include "lix/libstore/parsed-derivations.hh"
#include "lix/libstore/lock.hh"
#include "lix/libstore/outputs-spec.hh"
#include "lix/libstore/store-api.hh"
#include "lix/libstore/pathlocks.hh"
#include "lix/libstore/build/goal.hh"
#include <kj/time.h>
 
namespace nix {
 
using std::map;
 
struct HookInstance;
 
struct HookReplyBase {
    struct [[nodiscard]] Accept {
        kj::Promise<Outcome<void, Goal::WorkResult>> promise;
    };
    struct [[nodiscard]] Decline {};
    struct [[nodiscard]] Postpone {};
};
 
struct [[nodiscard]] HookReply
    : HookReplyBase,
      std::variant<HookReplyBase::Accept, HookReplyBase::Decline, HookReplyBase::Postpone>
{
    HookReply() = delete;
    using variant::variant;
};

enum struct PathStatus {
    Corrupt,
    Absent,
    Valid,
};
 
struct InitialOutputStatus {
    StorePath path;
    PathStatus status;
    bool isValid() const {
        return status == PathStatus::Valid;
    }

    bool isPresent() const {
        return status == PathStatus::Corrupt
            || status == PathStatus::Valid;
    }
};
 
struct InitialOutput {
    bool wanted;
    Hash outputHash;
    std::optional<InitialOutputStatus> known = {};
};

struct DerivationGoal : public Goal
{
    struct InputStream;

    bool isDone = false;

    bool useDerivation;

    StorePath drvPath;

    std::shared_ptr<DerivationGoal> resolvedDrvGoal;

    OutputsSpec wantedOutputs;

    std::map<std::pair<StorePath, std::string>, StorePath> inputDrvOutputs;

    enum struct NeedRestartForMoreOutputs {
        OutputsUnmodifedDontNeed,
        OutputsAddedDoNeed,
        BuildInProgressWillNotNeed,
    };

    NeedRestartForMoreOutputs needRestart = NeedRestartForMoreOutputs::OutputsUnmodifedDontNeed;
 
    bool anyHashMismatchSeen = false;
    bool anyCheckMismatchSeen = false;

    enum RetrySubstitution {
        NoNeed,
        YesNeed,
        AlreadyRetried,
    };

    RetrySubstitution retrySubstitution = RetrySubstitution::NoNeed;

    std::unique_ptr<Derivation> drv;
 
    std::unique_ptr<ParsedDerivation> parsedDrv;


    std::optional<PathLocks> outputLocks;

    StorePathSet inputPaths;
 
    std::map<std::string, InitialOutput> initialOutputs;

    BuildResult buildResult;

    AutoCloseFD fdLogFile;
    std::shared_ptr<BufferedSink> logFileSink, logSink;

    unsigned long logSize;

    std::list<std::string> logTail;
 
    std::string currentLogLine;
    size_t currentLogLinePos = 0; // to handle carriage return
 
    std::string currentHookLine;

    std::unique_ptr<HookInstance> hook;

    AutoCloseFD * builderOutFD = nullptr;

    std::optional<DerivationType> derivationType;
 
    BuildMode buildMode;
 
    NotifyingCounter<uint64_t>::Bump mcExpectedBuilds, mcRunningBuilds;
 
    std::unique_ptr<Activity> act;

    std::unique_ptr<Activity> actLock;
 
    std::map<ActivityId, Activity> builderActivities;

    std::string machineName;

    struct DrvHasRoot { explicit DrvHasRoot() = default; };
 
    DerivationGoal(const StorePath & drvPath,
        const OutputsSpec & wantedOutputs, Worker & worker, bool isDependency,
        BuildMode buildMode = bmNormal);
    DerivationGoal(DrvHasRoot, const StorePath & drvPath, const BasicDerivation & drv,
        const OutputsSpec & wantedOutputs, Worker & worker, bool isDependency,
        BuildMode buildMode = bmNormal);
    virtual ~DerivationGoal() noexcept(false);
 
    WorkResult timedOut(Error && ex);
 
    kj::Promise<Result<WorkResult>> workImpl() noexcept override;

    bool addWantedOutputs(const OutputsSpec & outputs);

    kj::Promise<Result<WorkResult>> getDerivation() noexcept;
    kj::Promise<Result<WorkResult>> loadDerivation() noexcept;
    kj::Promise<Result<WorkResult>> haveDerivation() noexcept;
    kj::Promise<Result<WorkResult>> outputsSubstitutionTried() noexcept;
    kj::Promise<Result<WorkResult>> gaveUpOnSubstitution() noexcept;
    kj::Promise<Result<WorkResult>> closureRepaired() noexcept;
    kj::Promise<Result<WorkResult>> inputsRealised() noexcept;
    kj::Promise<Result<WorkResult>> tryToBuild() noexcept;
    virtual kj::Promise<Result<WorkResult>> tryLocalBuild() noexcept;
    kj::Promise<Result<WorkResult>> buildDone() noexcept;
 
    kj::Promise<Result<WorkResult>> resolvedFinished() noexcept;

    HookReply tryBuildHook();
 
    virtual int getChildStatus();

    virtual kj::Promise<Result<SingleDrvOutputs>> registerOutputs();

    Path openLogFile();

    virtual void signRealisation(Realisation&) {}

    void closeLogFile();

    virtual void closeReadPipes();

    virtual void cleanupHookFinally();
    virtual void cleanupPreChildKill();
    virtual void cleanupPostChildKill();
    virtual bool cleanupDecideWhetherDiskFull();
    virtual void cleanupPostOutputsRegisteredModeCheck();
    virtual void cleanupPostOutputsRegisteredModeNonCheck();
 
protected:
    kj::TimePoint lastChildActivity = kj::minValue;
 
    kj::Promise<Outcome<void, WorkResult>> handleChildOutput() noexcept;
    kj::Promise<Outcome<void, WorkResult>>
    handleChildStreams(InputStream & builderIn, InputStream * hookIn) noexcept;
    kj::Promise<Outcome<void, WorkResult>> handleBuilderOutput(InputStream & in) noexcept;
    kj::Promise<Outcome<void, WorkResult>> handleHookOutput(InputStream & in) noexcept;
    kj::Promise<Outcome<void, WorkResult>> monitorForSilence() noexcept;
    WorkResult tooMuchLogs();
    void flushLine();
 
public:
    kj::Promise<Result<std::map<std::string, std::optional<StorePath>>>> queryPartialDerivationOutputMap();
    kj::Promise<Result<OutputPathMap>> queryDerivationOutputMap();

    kj::Promise<Result<std::pair<bool, SingleDrvOutputs>>> checkPathValidity();

    kj::Promise<Result<SingleDrvOutputs>> assertPathValidity();

    virtual void killChild();
 
    kj::Promise<Result<WorkResult>> repairClosure() noexcept;
 
    void started();
 
    WorkResult done(
        BuildResult::Status status,
        SingleDrvOutputs builtOutputs = {},
        std::optional<Error> ex = {});
 
    void waiteeDone(GoalPtr waitee) override;
 
    virtual bool respectsTimeouts()
    {
        return false;
    }
 
    StorePathSet exportReferences(const StorePathSet & storePaths);
 
    JobCategory jobCategory() const override {
        return JobCategory::Build;
    };
};
 
MakeError(NotDeterministic, BuildError);
 
}