Add nix ps command

src/libfetchers/git-utils.cc

@@ -359,7 +359,7 @@ struct GitRepoImpl : GitRepo, std::enable_shared_from_this<GitRepoImpl>
 
         ThreadPool pool;
 
-        auto process = [&done, &pool, &repoPool](this const auto & process, const git_oid & oid) -> void {
+        auto process = [&done, &pool, &repoPool](this auto const & process, const git_oid & oid) -> void {
             auto repo(repoPool.get());
 
             auto _commit = lookupObject(*repo, oid, GIT_OBJECT_COMMIT);

src/libmain/progress-bar.cc

@@ -470,11 +470,7 @@ class ProgressBar : public Logger
             }
         }
 
-        auto width = getWindowSize().second;
-        if (width <= 0)
-            width = std::numeric_limits<decltype(width)>::max();
-
-        redraw("\r" + filterANSIEscapes(line, false, width) + ANSI_NORMAL + "\e[K");
+        redraw("\r" + filterANSIEscapes(line, false, getWindowWidth()) + ANSI_NORMAL + "\e[K");
 
         return nextWakeup;
     }

src/libstore/active-builds.cc

@@ -0,0 +1,145 @@
+#include "nix/store/active-builds.hh"
+#include "nix/util/json-utils.hh"
+
+#include <nlohmann/json.hpp>
+
+#ifndef _WIN32
+#  include <pwd.h>
+#endif
+
+namespace nix {
+
+UserInfo UserInfo::fromUid(uid_t uid)
+{
+    UserInfo info;
+    info.uid = uid;
+
+#ifndef _WIN32
+    // Look up the user name for the UID (thread-safe)
+    struct passwd pwd;
+    struct passwd * result;
+    std::vector<char> buf(16384);
+    if (getpwuid_r(uid, &pwd, buf.data(), buf.size(), &result) == 0 && result)
+        info.name = result->pw_name;
+#endif
+
+    return info;
+}
+
+} // namespace nix
+
+namespace nlohmann {
+
+using namespace nix;
+
+UserInfo adl_serializer<UserInfo>::from_json(const json & j)
+{
+    return UserInfo{
+        .uid = j.at("uid").get<uid_t>(),
+        .name = j.contains("name") && !j.at("name").is_null()
+                    ? std::optional<std::string>(j.at("name").get<std::string>())
+                    : std::nullopt,
+    };
+}
+
+void adl_serializer<UserInfo>::to_json(json & j, const UserInfo & info)
+{
+    j = nlohmann::json{
+        {"uid", info.uid},
+        {"name", info.name},
+    };
+}
+
+// Durations are serialized as floats representing seconds.
+static std::optional<std::chrono::microseconds> parseDuration(const json & j, const char * key)
+{
+    if (j.contains(key) && !j.at(key).is_null())
+        return std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::duration<float, std::chrono::seconds::period>(j.at(key).get<double>()));
+    else
+        return std::nullopt;
+}
+
+static nlohmann::json printDuration(const std::optional<std::chrono::microseconds> & duration)
+{
+    return duration
+               ? nlohmann::json(
+                     std::chrono::duration_cast<std::chrono::duration<float, std::chrono::seconds::period>>(*duration)
+                         .count())
+               : nullptr;
+}
+
+ActiveBuildInfo::ProcessInfo adl_serializer<ActiveBuildInfo::ProcessInfo>::from_json(const json & j)
+{
+    return ActiveBuildInfo::ProcessInfo{
+        .pid = j.at("pid").get<pid_t>(),
+        .parentPid = j.at("parentPid").get<pid_t>(),
+        .user = j.at("user").get<UserInfo>(),
+        .argv = j.at("argv").get<std::vector<std::string>>(),
+        .utime = parseDuration(j, "utime"),
+        .stime = parseDuration(j, "stime"),
+        .cutime = parseDuration(j, "cutime"),
+        .cstime = parseDuration(j, "cstime"),
+    };
+}
+
+void adl_serializer<ActiveBuildInfo::ProcessInfo>::to_json(json & j, const ActiveBuildInfo::ProcessInfo & process)
+{
+    j = nlohmann::json{
+        {"pid", process.pid},
+        {"parentPid", process.parentPid},
+        {"user", process.user},
+        {"argv", process.argv},
+        {"utime", printDuration(process.utime)},
+        {"stime", printDuration(process.stime)},
+        {"cutime", printDuration(process.cutime)},
+        {"cstime", printDuration(process.cstime)},
+    };
+}
+
+ActiveBuild adl_serializer<ActiveBuild>::from_json(const json & j)
+{
+    return ActiveBuild{
+        .nixPid = j.at("nixPid").get<pid_t>(),
+        .clientPid = j.at("clientPid").get<std::optional<pid_t>>(),
+        .clientUid = j.at("clientUid").get<std::optional<uid_t>>(),
+        .mainPid = j.at("mainPid").get<pid_t>(),
+        .mainUser = j.at("mainUser").get<UserInfo>(),
+        .cgroup = j.at("cgroup").get<std::optional<Path>>(),
+        .startTime = (time_t) j.at("startTime").get<double>(),
+        .derivation = StorePath{getString(j.at("derivation"))},
+    };
+}
+
+void adl_serializer<ActiveBuild>::to_json(json & j, const ActiveBuild & build)
+{
+    j = nlohmann::json{
+        {"nixPid", build.nixPid},
+        {"clientPid", build.clientPid},
+        {"clientUid", build.clientUid},
+        {"mainPid", build.mainPid},
+        {"mainUser", build.mainUser},
+        {"cgroup", build.cgroup},
+        {"startTime", (double) build.startTime},
+        {"derivation", build.derivation.to_string()},
+    };
+}
+
+ActiveBuildInfo adl_serializer<ActiveBuildInfo>::from_json(const json & j)
+{
+    ActiveBuildInfo info(adl_serializer<ActiveBuild>::from_json(j));
+    info.processes = j.at("processes").get<std::vector<ActiveBuildInfo::ProcessInfo>>();
+    info.utime = parseDuration(j, "utime");
+    info.stime = parseDuration(j, "stime");
+    return info;
+}
+
+void adl_serializer<ActiveBuildInfo>::to_json(json & j, const ActiveBuildInfo & build)
+{
+    adl_serializer<ActiveBuild>::to_json(j, build);
+    j["processes"] = build.processes;
+    j["utime"] = printDuration(build.utime);
+    j["stime"] = printDuration(build.stime);
+}
+
+} // namespace nlohmann

src/libstore/daemon.cc

@@ -17,6 +17,7 @@
 #include "nix/util/git.hh"
 #include "nix/util/logging.hh"
 #include "nix/store/globals.hh"
+#include "nix/store/active-builds.hh"
 
 #ifndef _WIN32 // TODO need graceful async exit support on Windows?
 #  include "nix/util/monitor-fd.hh"
@@ -1014,6 +1015,15 @@ static void performOp(
     case WorkerProto::Op::ClearFailedPaths:
         throw Error("Removed operation %1%", op);
 
+    case WorkerProto::Op::QueryActiveBuilds: {
+        logger->startWork();
+        auto & activeBuildsStore = require<QueryActiveBuildsStore>(*store);
+        auto activeBuilds = activeBuildsStore.queryActiveBuilds();
+        logger->stopWork();
+        conn.to << nlohmann::json(activeBuilds).dump();
+        break;
+    }
+
     default:
         throw Error("invalid operation %1%", op);
     }

src/libstore/include/nix/store/active-builds.hh

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "nix/util/util.hh"
+#include "nix/util/json-impls.hh"
+#include "nix/store/path.hh"
+
+#include <chrono>
+#include <sys/types.h>
+
+namespace nix {
+
+/**
+ * A uid and optional corresponding user name.
+ */
+struct UserInfo
+{
+    uid_t uid = -1;
+    std::optional<std::string> name;
+
+    /**
+     * Create a UserInfo from a UID, looking up the username if possible.
+     */
+    static UserInfo fromUid(uid_t uid);
+};
+
+struct ActiveBuild
+{
+    pid_t nixPid;
+
+    std::optional<pid_t> clientPid;
+    std::optional<uid_t> clientUid;
+
+    pid_t mainPid;
+    UserInfo mainUser;
+    std::optional<Path> cgroup;
+
+    time_t startTime;
+
+    StorePath derivation;
+};
+
+struct ActiveBuildInfo : ActiveBuild
+{
+    struct ProcessInfo
+    {
+        pid_t pid = 0;
+        pid_t parentPid = 0;
+        UserInfo user;
+        std::vector<std::string> argv;
+        std::optional<std::chrono::microseconds> utime, stime, cutime, cstime;
+    };
+
+    // User/system CPU time for the entire cgroup, if available.
+    std::optional<std::chrono::microseconds> utime, stime;
+
+    std::vector<ProcessInfo> processes;
+};
+
+struct TrackActiveBuildsStore
+{
+    struct BuildHandle
+    {
+        TrackActiveBuildsStore & tracker;
+        uint64_t id;
+
+        BuildHandle(TrackActiveBuildsStore & tracker, uint64_t id)
+            : tracker(tracker)
+            , id(id)
+        {
+        }
+
+        BuildHandle(BuildHandle && other) noexcept
+            : tracker(other.tracker)
+            , id(other.id)
+        {
+            other.id = 0;
+        }
+
+        ~BuildHandle()
+        {
+            if (id) {
+                try {
+                    tracker.buildFinished(*this);
+                } catch (...) {
+                    ignoreExceptionInDestructor();
+                }
+            }
+        }
+    };
+
+    virtual BuildHandle buildStarted(const ActiveBuild & build) = 0;
+
+    virtual void buildFinished(const BuildHandle & handle) = 0;
+};
+
+struct QueryActiveBuildsStore
+{
+    inline static std::string operationName = "Querying active builds";
+
+    virtual std::vector<ActiveBuildInfo> queryActiveBuilds() = 0;
+};
+
+} // namespace nix
+
+JSON_IMPL(UserInfo)
+JSON_IMPL(ActiveBuild)
+JSON_IMPL(ActiveBuildInfo)
+JSON_IMPL(ActiveBuildInfo::ProcessInfo)

src/libstore/include/nix/store/local-store.hh

@@ -6,6 +6,7 @@
 #include "nix/store/pathlocks.hh"
 #include "nix/store/store-api.hh"
 #include "nix/store/indirect-root-store.hh"
+#include "nix/store/active-builds.hh"
 #include "nix/util/sync.hh"
 
 #include <chrono>
@@ -125,7 +126,10 @@ public:
     StoreReference getReference() const override;
 };
 
-class LocalStore : public virtual IndirectRootStore, public virtual GcStore
+class LocalStore : public virtual IndirectRootStore,
+                   public virtual GcStore,
+                   public virtual TrackActiveBuildsStore,
+                   public virtual QueryActiveBuildsStore
 {
 public:
 
@@ -457,6 +461,24 @@ private:
 
     friend struct PathSubstitutionGoal;
     friend struct DerivationGoal;
+
+private:
+
+    std::filesystem::path activeBuildsDir;
+
+    struct ActiveBuildFile
+    {
+        AutoCloseFD fd;
+        AutoDelete del;
+    };
+
+    Sync<std::unordered_map<uint64_t, ActiveBuildFile>> activeBuilds;
+
+    std::vector<ActiveBuildInfo> queryActiveBuilds() override;
+
+    BuildHandle buildStarted(const ActiveBuild & build) override;
+
+    void buildFinished(const BuildHandle & handle) override;
 };
 
 } // namespace nix

src/libstore/include/nix/store/meson.build

@@ -10,6 +10,7 @@ config_pub_h = configure_file(
 )
 
 headers = [ config_pub_h ] + files(
+  'active-builds.hh',
   'async-path-writer.hh',
   'aws-creds.hh',
   'binary-cache-store.hh',

src/libstore/include/nix/store/remote-store.hh

@@ -7,6 +7,7 @@
 #include "nix/store/store-api.hh"
 #include "nix/store/gc-store.hh"
 #include "nix/store/log-store.hh"
+#include "nix/store/active-builds.hh"
 
 namespace nix {
 
@@ -36,7 +37,10 @@ struct RemoteStoreConfig : virtual StoreConfig
  * \todo RemoteStore is a misnomer - should be something like
  * DaemonStore.
  */
-struct RemoteStore : public virtual Store, public virtual GcStore, public virtual LogStore
+struct RemoteStore : public virtual Store,
+                     public virtual GcStore,
+                     public virtual LogStore,
+                     public virtual QueryActiveBuildsStore
 {
     using Config = RemoteStoreConfig;
 
@@ -143,6 +147,8 @@ struct RemoteStore : public virtual Store, public virtual GcStore, public virtua
 
     void addBuildLog(const StorePath & drvPath, std::string_view log) override;
 
+    std::vector<ActiveBuildInfo> queryActiveBuilds() override;
+
     std::optional<std::string> getVersion() override;
 
     void connect() override;

src/libstore/include/nix/store/worker-protocol.hh

@@ -138,6 +138,8 @@ struct WorkerProto
     using Feature = std::string;
     using FeatureSet = std::set<Feature, std::less<>>;
 
+    static constexpr std::string_view featureQueryActiveBuilds{"queryActiveBuilds"};
+
     static const FeatureSet allFeatures;
 };
 
@@ -186,6 +188,7 @@ enum struct WorkerProto::Op : uint64_t {
     AddBuildLog = 45,
     BuildPathsWithResults = 46,
     AddPermRoot = 47,
+    QueryActiveBuilds = 48,
 };
 
 struct WorkerProto::ClientHandshakeInfo