build-result.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libstore/realisation.hh"
#include "lix/libstore/derived-path.hh"
#include "lix/libutil/comparator.hh"
 
#include <string>
#include <chrono>
#include <optional>
 
namespace nix {
 
struct KeyedBuildResult;
 
struct BuildResult
{
    enum Status {
        Built = 0,
        Substituted,
        AlreadyValid,
        PermanentFailure,
        InputRejected,
        OutputRejected,
        TransientFailure,
        CachedFailure,
        TimedOut,
        MiscFailure,
        DependencyFailed,
        LogLimitExceeded,
        NotDeterministic,
        ResolvesToAlreadyValid,
        NoSubstituters,
    } status = MiscFailure;

    std::string errorMsg = {};
 
    std::string toString() const {
        auto strStatus = [&]() {
            switch (status) {
                case Built: return "Built";
                case Substituted: return "Substituted";
                case AlreadyValid: return "AlreadyValid";
                case PermanentFailure: return "PermanentFailure";
                case InputRejected: return "InputRejected";
                case OutputRejected: return "OutputRejected";
                case TransientFailure: return "TransientFailure";
                case CachedFailure: return "CachedFailure";
                case TimedOut: return "TimedOut";
                case MiscFailure: return "MiscFailure";
                case DependencyFailed: return "DependencyFailed";
                case LogLimitExceeded: return "LogLimitExceeded";
                case NotDeterministic: return "NotDeterministic";
                case ResolvesToAlreadyValid: return "ResolvesToAlreadyValid";
                case NoSubstituters: return "NoSubstituters";
                default: return "Unknown";
            };
        }();
        return strStatus + ((errorMsg == "") ? "" : " : " + errorMsg);
    }

    unsigned int timesBuilt = 0;

    bool isNonDeterministic = false;

    SingleDrvOutputs builtOutputs = {};

    time_t startTime = 0, stopTime = 0;

    std::optional<std::chrono::microseconds> cpuUser, cpuSystem;
 
    DECLARE_CMP(BuildResult);
 
    bool success()
    {
        return status == Built || status == Substituted || status == AlreadyValid || status == ResolvesToAlreadyValid;
    }
 
    void rethrow()
    {
        throw Error("%s", errorMsg);
    }

    KeyedBuildResult restrictTo(DerivedPath path) const;
};

struct KeyedBuildResult : BuildResult
{
    DerivedPath path;
};
 
}