path: root/third_party/nix/src/nix-build/nix-build.cc

#include <cstring>
#include <fstream>
#include <iostream>
#include <regex>
#include <sstream>
#include <vector>

#include <absl/strings/ascii.h>
#include <absl/strings/str_split.h>
#include <glog/logging.h>

#include "libexpr/attr-path.hh"
#include "libexpr/common-eval-args.hh"
#include "libexpr/eval-inline.hh"
#include "libexpr/eval.hh"
#include "libexpr/get-drvs.hh"
#include "libmain/shared.hh"
#include "libstore/derivations.hh"
#include "libstore/globals.hh"
#include "libstore/store-api.hh"
#include "libutil/affinity.hh"
#include "libutil/status.hh"
#include "libutil/util.hh"
#include "nix/legacy.hh"

using namespace nix;
using namespace std::string_literals;

/* Recreate the effect of the perl shellwords function, breaking up a
 * string into arguments like a shell word, including escapes
 */
std::vector<std::string> shellwords(const std::string& s) {
  std::regex whitespace("^(\\s+).*");
  auto begin = s.cbegin();
  std::vector<std::string> res;
  std::string cur;
  enum state { sBegin, sQuote };
  state st = sBegin;
  auto it = begin;
  for (; it != s.cend(); ++it) {
    if (st == sBegin) {
      std::smatch match;
      if (regex_search(it, s.cend(), match, whitespace)) {
        cur.append(begin, it);
        res.push_back(cur);
        cur.clear();
        it = match[1].second;
        begin = it;
      }
    }
    switch (*it) {
      case '"':
        cur.append(begin, it);
        begin = it + 1;
        st = st == sBegin ? sQuote : sBegin;
        break;
      case '\\':
        /* perl shellwords mostly just treats the next char as part of the
         * string with no special processing */
        cur.append(begin, it);
        begin = ++it;
        break;
    }
  }
  cur.append(begin, it);
  if (!cur.empty()) {
    res.push_back(cur);
  }
  return res;
}

static void _main(int argc, char** argv) {
  auto dryRun = false;
  auto runEnv = std::regex_search(argv[0], std::regex("nix-shell$"));
  auto pure = false;
  auto fromArgs = false;
  auto packages = false;
  // Same condition as bash uses for interactive shells
  auto interactive =
      (isatty(STDIN_FILENO) != 0) && (isatty(STDERR_FILENO) != 0);
  Strings attrPaths;
  Strings left;
  RepairFlag repair = NoRepair;
  Path gcRoot;
  BuildMode buildMode = bmNormal;
  bool readStdin = false;

  std::string envCommand;  // interactive shell
  Strings envExclude;

  auto myName = runEnv ? "nix-shell" : "nix-build";

  auto inShebang = false;
  std::string script;
  std::vector<std::string> savedArgs;

  AutoDelete tmpDir(createTempDir("", myName));

  std::string outLink = "./result";

  // List of environment variables kept for --pure
  std::set<std::string> keepVars{
      "HOME",         "USER", "LOGNAME", "DISPLAY",         "PATH", "TERM",
      "IN_NIX_SHELL", "TZ",   "PAGER",   "NIX_BUILD_SHELL", "SHLVL"};

  Strings args;
  for (int i = 1; i < argc; ++i) {
    args.push_back(argv[i]);
  }

  // Heuristic to see if we're invoked as a shebang script, namely,
  // if we have at least one argument, it's the name of an
  // executable file, and it starts with "#!".
  if (runEnv && argc > 1 &&
      !std::regex_search(argv[1], std::regex("nix-shell"))) {
    script = argv[1];
    try {
      Strings lines = absl::StrSplit(readFile(script), absl::ByChar('\n'),
                                     absl::SkipEmpty());
      if (std::regex_search(lines.front(), std::regex("^#!"))) {
        lines.pop_front();
        inShebang = true;
        for (int i = 2; i < argc; ++i) {
          savedArgs.emplace_back(argv[i]);
        }
        args.clear();
        for (auto line : lines) {
          line = absl::StripTrailingAsciiWhitespace(line);
          std::smatch match;
          if (std::regex_match(line, match,
                               std::regex("^#!\\s*nix-shell (.*)$"))) {
            for (const auto& word : shellwords(match[1].str())) {
              args.push_back(word);
            }
          }
        }
      }
    } catch (SysError&) {
    }
  }

  struct MyArgs : LegacyArgs, MixEvalArgs {
    using LegacyArgs::LegacyArgs;
  };

  MyArgs myArgs(
      myName, [&](Strings::iterator& arg, const Strings::iterator& end) {
        if (*arg == "--help") {
          deletePath(Path(tmpDir));
          showManPage(myName);
        }

        else if (*arg == "--version") {
          printVersion(myName);

        } else if (*arg == "--add-drv-link" || *arg == "--indirect") {
          ;  // obsolete

        } else if (*arg == "--no-out-link" || *arg == "--no-link") {
          outLink = Path(tmpDir) + "/result";

        } else if (*arg == "--attr" || *arg == "-A") {
          attrPaths.push_back(getArg(*arg, arg, end));

        } else if (*arg == "--drv-link") {
          getArg(*arg, arg, end);  // obsolete

        } else if (*arg == "--out-link" || *arg == "-o") {
          outLink = getArg(*arg, arg, end);

        } else if (*arg == "--add-root") {
          gcRoot = getArg(*arg, arg, end);

        } else if (*arg == "--dry-run") {
          dryRun = true;

        } else if (*arg == "--repair") {
          repair = Repair;
          buildMode = bmRepair;
        }

        else if (*arg == "--run-env") {  // obsolete
          runEnv = true;

        } else if (*arg == "--command" || *arg == "--run") {
          if (*arg == "--run") {
            interactive = false;
          }
          envCommand = getArg(*arg, arg, end) + "\nexit";
        }

        else if (*arg == "--check") {
          buildMode = bmCheck;

        } else if (*arg == "--exclude") {
          envExclude.push_back(getArg(*arg, arg, end));

        } else if (*arg == "--expr" || *arg == "-E") {
          fromArgs = true;

        } else if (runEnv && *arg == "--pure") {
          pure = true;
        } else if (runEnv && *arg == "--impure") {
          pure = false;

        } else if (*arg == "--packages" || *arg == "-p") {
          packages = true;

        } else if (inShebang && *arg == "-i") {
          auto interpreter = getArg(*arg, arg, end);
          interactive = false;
          auto execArgs = "";

          // Überhack to support Perl. Perl examines the shebang and
          // executes it unless it contains the string "perl" or "indir",
          // or (undocumented) argv[0] does not contain "perl". Exploit
          // the latter by doing "exec -a".
          if (std::regex_search(interpreter, std::regex("perl"))) {
            execArgs = "-a PERL";
          }

          std::ostringstream joined;
          for (const auto& i : savedArgs) {
            joined << shellEscape(i) << ' ';
          }

          if (std::regex_search(interpreter, std::regex("ruby"))) {
            // Hack for Ruby. Ruby also examines the shebang. It tries to
            // read the shebang to understand which packages to read from. Since
            // this is handled via nix-shell -p, we wrap our ruby script
            // execution in ruby -e 'load' which ignores the shebangs.
            envCommand = (format("exec %1% %2% -e 'load(\"%3%\")' -- %4%") %
                          execArgs % interpreter % script % joined.str())
                             .str();
          } else {
            envCommand = (format("exec %1% %2% %3% %4%") % execArgs %
                          interpreter % script % joined.str())
                             .str();
          }
        }

        else if (*arg == "--keep") {
          keepVars.insert(getArg(*arg, arg, end));

        } else if (*arg == "-") {
          readStdin = true;

        } else if (*arg != "" && arg->at(0) == '-') {
          return false;

        } else {
          left.push_back(*arg);
        }

        return true;
      });

  myArgs.parseCmdline(args);

  if (packages && fromArgs) {
    throw UsageError("'-p' and '-E' are mutually exclusive");
  }

  auto store = openStore();

  auto state = std::make_unique<EvalState>(myArgs.searchPath, store);
  state->repair = repair;

  std::unique_ptr<Bindings> autoArgs = myArgs.getAutoArgs(*state);

  if (packages) {
    std::ostringstream joined;
    joined << "with import <nixpkgs> { }; (pkgs.runCommandCC or "
              "pkgs.runCommand) \"shell\" { buildInputs = [ ";
    for (const auto& i : left) {
      joined << '(' << i << ") ";
    }
    joined << "]; } \"\"";
    fromArgs = true;
    left = {joined.str()};
  } else if (!fromArgs) {
    if (left.empty() && runEnv && pathExists("shell.nix")) {
      left = {"shell.nix"};
    }
    if (left.empty()) {
      left = {"default.nix"};
    }
  }

  if (runEnv) {
    setenv("IN_NIX_SHELL", pure ? "pure" : "impure", 1);
  }

  DrvInfos drvs;

  /* Parse the expressions. */
  std::vector<Expr*> exprs;

  if (readStdin) {
    exprs = {state->parseStdin()};
  } else {
    for (const auto& i : left) {
      if (fromArgs) {
        exprs.push_back(state->parseExprFromString(i, absPath(".")));
      } else {
        auto absolute = i;
        try {
          absolute = canonPath(absPath(i), true);
        } catch (Error& e) {
        };
        if (store->isStorePath(absolute) &&
            std::regex_match(absolute, std::regex(".*\\.drv(!.*)?"))) {
          drvs.push_back(DrvInfo(*state, store, absolute));
        } else {
          /* If we're in a #! script, interpret filenames
             relative to the script. */
          exprs.push_back(
              state->parseExprFromFile(resolveExprPath(state->checkSourcePath(
                  lookupFileArg(*state, inShebang && !packages
                                            ? absPath(i, absPath(dirOf(script)))
                                            : i)))));
        }
      }
    }
  }

  /* Evaluate them into derivations. */
  if (attrPaths.empty()) {
    attrPaths = {""};
  }

  for (auto e : exprs) {
    Value vRoot;
    state->eval(e, vRoot);

    for (auto& i : attrPaths) {
      Value& v(*findAlongAttrPath(*state, i, autoArgs.get(), vRoot));
      state->forceValue(v);
      getDerivations(*state, v, "", autoArgs.get(), drvs, false);
    }
  }

  state->printStats();

  auto buildPaths = [&](const PathSet& paths) {
    /* Note: we do this even when !printMissing to efficiently
       fetch binary cache data. */
    unsigned long long downloadSize;
    unsigned long long narSize;
    PathSet willBuild;
    PathSet willSubstitute;
    PathSet unknown;
    store->queryMissing(paths, willBuild, willSubstitute, unknown, downloadSize,
                        narSize);

    if (settings.printMissing) {
      printMissing(ref<Store>(store), willBuild, willSubstitute, unknown,
                   downloadSize, narSize);
    }

    if (!dryRun) {
      util::OkOrThrow(store->buildPaths(std::cerr, paths, buildMode));
    }
  };

  if (runEnv) {
    if (drvs.size() != 1) {
      throw UsageError("nix-shell requires a single derivation");
    }

    auto& drvInfo = drvs.front();
    auto drv = store->derivationFromPath(drvInfo.queryDrvPath());

    PathSet pathsToBuild;

    /* Figure out what bash shell to use. If $NIX_BUILD_SHELL
       is not set, then build bashInteractive from
       <nixpkgs>. */
    auto shell = getEnv("NIX_BUILD_SHELL", "");

    if (shell.empty()) {
      try {
        auto expr = state->parseExprFromString(
            "(import <nixpkgs> {}).bashInteractive", absPath("."));

        Value v;
        state->eval(expr, v);

        auto drv = getDerivation(*state, v, false);
        if (!drv) {
          throw Error(
              "the 'bashInteractive' attribute in <nixpkgs> did not evaluate "
              "to a derivation");
        }

        pathsToBuild.insert(drv->queryDrvPath());

        shell = drv->queryOutPath() + "/bin/bash";

      } catch (Error& e) {
        LOG(WARNING) << e.what() << "; will use bash from your environment";
        shell = "bash";
      }
    }

    // Build or fetch all dependencies of the derivation.
    for (const auto& input : drv.inputDrvs) {
      if (std::all_of(envExclude.cbegin(), envExclude.cend(),
                      [&](const std::string& exclude) {
                        return !std::regex_search(input.first,
                                                  std::regex(exclude));
                      })) {
        pathsToBuild.insert(makeDrvPathWithOutputs(input.first, input.second));
      }
    }
    for (const auto& src : drv.inputSrcs) {
      pathsToBuild.insert(src);
    }

    buildPaths(pathsToBuild);

    if (dryRun) {
      return;
    }

    // Set the environment.
    auto env = getEnv();

    auto tmp = getEnv("TMPDIR", getEnv("XDG_RUNTIME_DIR", "/tmp"));

    if (pure) {
      decltype(env) newEnv;
      for (auto& i : env) {
        if (keepVars.count(i.first) != 0u) {
          newEnv.emplace(i);
        }
      }
      env = newEnv;
      // NixOS hack: prevent /etc/bashrc from sourcing /etc/profile.
      env["__ETC_PROFILE_SOURCED"] = "1";
    }

    env["NIX_BUILD_TOP"] = env["TMPDIR"] = env["TEMPDIR"] = env["TMP"] =
        env["TEMP"] = tmp;
    env["NIX_STORE"] = store->storeDir;
    env["NIX_BUILD_CORES"] = std::to_string(settings.buildCores);

    StringSet passAsFile =
        absl::StrSplit(get(drv.env, "passAsFile", ""),
                       absl::ByAnyChar(" \t\n\r"), absl::SkipEmpty());

    bool keepTmp = false;
    int fileNr = 0;

    for (auto& var : drv.env) {
      if (passAsFile.count(var.first) != 0u) {
        keepTmp = true;
        std::string fn = ".attr-" + std::to_string(fileNr++);
        Path p = Path(tmpDir) + "/" + fn;
        writeFile(p, var.second);
        env[var.first + "Path"] = p;
      } else {
        env[var.first] = var.second;
      }
    }

    restoreAffinity();

    /* Run a shell using the derivation's environment.  For
       convenience, source $stdenv/setup to setup additional
       environment variables and shell functions.  Also don't
       lose the current $PATH directories. */
    auto rcfile = Path(tmpDir) + "/rc";
    writeFile(
        rcfile,
        fmt((keepTmp ? "" : "rm -rf '%1%'; "s) +
                "[ -n \"$PS1\" ] && [ -e ~/.bashrc ] && source ~/.bashrc; "
                "%2%"
                "dontAddDisableDepTrack=1; "
                "[ -e $stdenv/setup ] && source $stdenv/setup; "
                "%3%"
                "PATH=\"%4%:$PATH\"; "
                "SHELL=%5%; "
                "set +e; "
                R"s([ -n "$PS1" ] && PS1='\n\[\033[1;32m\][nix-shell:\w]\$\[\033[0m\] '; )s"
                "if [ \"$(type -t runHook)\" = function ]; then runHook "
                "shellHook; fi; "
                "unset NIX_ENFORCE_PURITY; "
                "shopt -u nullglob; "
                "unset TZ; %6%"
                "%7%",
            Path(tmpDir), (pure ? "" : "p=$PATH; "),
            (pure ? "" : "PATH=$PATH:$p; unset p; "), dirOf(shell), shell,
            (getenv("TZ") != nullptr
                 ? (std::string("export TZ='") + getenv("TZ") + "'; ")
                 : ""),
            envCommand));

    Strings envStrs;
    for (auto& i : env) {
      envStrs.push_back(i.first + "=" + i.second);
    }

    auto args = interactive ? Strings{"bash", "--rcfile", rcfile}
                            : Strings{"bash", rcfile};

    auto envPtrs = stringsToCharPtrs(envStrs);

    environ = envPtrs.data();

    auto argPtrs = stringsToCharPtrs(args);

    restoreSignals();

    execvp(shell.c_str(), argPtrs.data());

    throw SysError("executing shell '%s'", shell);
  }

  PathSet pathsToBuild;

  std::map<Path, Path> drvPrefixes;
  std::map<Path, Path> resultSymlinks;
  std::vector<Path> outPaths;

  for (auto& drvInfo : drvs) {
    auto drvPath = drvInfo.queryDrvPath();
    auto outPath = drvInfo.queryOutPath();

    auto outputName = drvInfo.queryOutputName();
    if (outputName.empty()) {
      throw Error("derivation '%s' lacks an 'outputName' attribute", drvPath);
    }

    pathsToBuild.insert(drvPath + "!" + outputName);

    std::string drvPrefix;
    auto i = drvPrefixes.find(drvPath);
    if (i != drvPrefixes.end()) {
      drvPrefix = i->second;
    } else {
      drvPrefix = outLink;
      if (!drvPrefixes.empty() != 0u) {
        drvPrefix += fmt("-%d", drvPrefixes.size() + 1);
      }
      drvPrefixes[drvPath] = drvPrefix;
    }

    std::string symlink = drvPrefix;
    if (outputName != "out") {
      symlink += "-" + outputName;
    }

    resultSymlinks[symlink] = outPath;
    outPaths.push_back(outPath);
  }

  buildPaths(pathsToBuild);

  if (dryRun) {
    return;
  }

  for (auto& symlink : resultSymlinks) {
    if (auto store2 = store.dynamic_pointer_cast<LocalFSStore>()) {
      store2->addPermRoot(symlink.second, absPath(symlink.first), true);
    }
  }

  for (auto& path : outPaths) {
    std::cout << path << '\n';
  }
}

static RegisterLegacyCommand s1("nix-build", _main);
static RegisterLegacyCommand s2("nix-shell", _main);