split nix-eval-jobs further into smaller files

src/buffered-io.cc

@@ -0,0 +1,52 @@
+#include "buffered-io.hh"
+#include <string.h>
+#include <unistd.h>
+#include <nix/signals.hh>
+
+[[nodiscard]] int tryWriteLine(int fd, std::string s) {
+    s += "\n";
+    std::string_view sv{s};
+    while (!sv.empty()) {
+        nix::checkInterrupt();
+        ssize_t res = write(fd, sv.data(), sv.size());
+        if (res == -1 && errno != EINTR) {
+            return -errno;
+        }
+        if (res > 0) {
+            sv.remove_prefix(res);
+        }
+    }
+    return 0;
+}
+
+LineReader::LineReader(int fd) {
+    stream = fdopen(fd, "r");
+    if (!stream) {
+        throw nix::Error("fdopen failed: %s", strerror(errno));
+    }
+}
+
+LineReader::~LineReader() {
+    fclose(stream);
+    free(buffer);
+}
+
+LineReader::LineReader(LineReader &&other) {
+    stream = other.stream;
+    other.stream = nullptr;
+    buffer = other.buffer;
+    other.buffer = nullptr;
+    len = other.len;
+    other.len = 0;
+}
+
+[[nodiscard]] std::string_view LineReader::readLine() {
+    ssize_t read = getline(&buffer, &len, stream);
+
+    if (read == -1) {
+        return {}; // Return an empty string_view in case of error
+    }
+
+    // Remove trailing newline
+    return std::string_view(buffer, read - 1);
+}

src/buffered-io.hh

@@ -0,0 +1,20 @@
+#pragma once
+#include <cstdio>
+#include <string>
+#include <string_view>
+
+[[nodiscard]] int tryWriteLine(int fd, std::string s);
+
+class LineReader {
+  public:
+    LineReader(int fd);
+    ~LineReader();
+
+    LineReader(LineReader &&other);
+    [[nodiscard]] std::string_view readLine();
+
+  private:
+    FILE *stream = nullptr;
+    char *buffer = nullptr;
+    size_t len = 0;
+};

src/drv.cc

@@ -1,14 +1,13 @@
-#include "drvs.hh"
+#include "drv.hh"
 #include <nix/config.h>
 #include <nix/path-with-outputs.hh>
 #include <nix/store-api.hh>
 #include <nix/local-fs-store.hh>
 #include <nix/value-to-json.hh>
 #include <nix/derivations.hh>
 
-
 static bool queryIsCached(nix::Store &store,
-                   std::map<std::string, std::string> &outputs) {
+                          std::map<std::string, std::string> &outputs) {
     uint64_t downloadSize, narSize;
     nix::StorePathSet willBuild, willSubstitute, unknown;
 
@@ -23,7 +22,8 @@ static bool queryIsCached(nix::Store &store,
 }
 
 /* The fields of a derivation that are printed in json form */
-Drv::Drv(std::string &attrPath, nix::EvalState &state, nix::DrvInfo &drvInfo, MyArgs &args) {
+Drv::Drv(std::string &attrPath, nix::EvalState &state, nix::DrvInfo &drvInfo,
+         MyArgs &args) {
 
     auto localStore = state.store.dynamic_pointer_cast<nix::LocalFSStore>();
 
@@ -58,8 +58,9 @@ Drv::Drv(std::string &attrPath, nix::EvalState &state, nix::DrvInfo &drvInfo, My
         meta = meta_;
     }
     if (args.checkCacheStatus) {
-        cacheStatus = queryIsCached(*localStore, outputs) ? Drv::CacheStatus::Cached
-                                                          : Drv::CacheStatus::Uncached;
+        cacheStatus = queryIsCached(*localStore, outputs)
+                          ? Drv::CacheStatus::Cached
+                          : Drv::CacheStatus::Uncached;
     } else {
         cacheStatus = Drv::CacheStatus::Unknown;
     }

src/eval-args.cc

@@ -88,6 +88,6 @@ MyArgs::MyArgs() : MixCommonArgs("nix-eval-jobs") {
     expectArg("expr", &releaseExpr);
 }
 
-void MyArgs::parseArgs(char** argv, int argc) {
+void MyArgs::parseArgs(char **argv, int argc) {
     parseCmdline(nix::argvToStrings(argc, argv), 0);
 }

src/meson.build

@@ -1,7 +1,9 @@
 src = [
   'nix-eval-jobs.cc',
   'eval-args.cc',
-  'drv.cc'
+  'drv.cc',
+  'buffered-io.cc',
+  'worker.cc'
 ]
 
 executable('nix-eval-jobs', src,