TEMP

NixOS · Jan 20, 2024 · 31bdead · 31bdead
1 parent f7dc322
commit 31bdead
Show file tree

Hide file tree

Showing 7 changed files with 126 additions and 75 deletions.
diff --git a/src/libutil/args.cc b/src/libutil/args.cc
@@ -611,6 +611,25 @@ Args::Flag Args::Flag::mkHashAlgoOptFlag(std::string && longName, std::optional<
     };
 }
 
+Args::Flag Args::Flag::mkFileIngestionMethodFlag(FileIngestionMethod * method)
+{
+    return Flag {
+        .longName  = "mode",
+        .description = R"(
+          How to compute the hash of the input.
+          One of:
+
+          - `nar` (the default): Serialises the input as an archive (following the [_Nix Archive Format_](https://edolstra.github.io/pubs/phd-thesis.pdf#page=101)) and passes that to the hash function.
+
+          - `flat`: Assumes that the input is a single file and directly passes it to the hash function;
+        )",
+        .labels = {"hash-mode"},
+        .handler = {[method](std::string s) {
+            *method = parseFileIngestionMethod(s);
+        }},
+    };
+}
+
 static void _completePath(AddCompletions & completions, std::string_view prefix, bool onlyDirs)
 {
     completions.setType(Completions::Type::Filenames);

diff --git a/src/libutil/args.hh b/src/libutil/args.hh
@@ -11,6 +11,7 @@
 
 #include "types.hh"
 #include "experimental-features.hh"
+#include "file-content-address.hh"
 
 namespace nix {
 
@@ -185,7 +186,11 @@ protected:
             return mkHashAlgoOptFlag("hash-algo", oha);
         }
         static Flag mkHashFormatFlagWithDefault(std::string && longName, HashFormat * hf);
+        static Flag mkHashFormatFlagWithDefault(HashFormat * hf) {
+            return mkHashFormatFlagWithDefault("hash-format", hf);
+        }
         static Flag mkHashFormatOptFlag(std::string && longName, std::optional<HashFormat> * ohf);
+        static Flag mkFileIngestionMethodFlag(FileIngestionMethod * method);
     };
 
     /**

diff --git a/src/libutil/file-content-address.cc b/src/libutil/file-content-address.cc
@@ -3,6 +3,18 @@
 
 namespace nix {
 
+FileIngestionMethod parseFileIngestionMethod(std::string_view input)
+{
+    if (input == "flat") {
+        return FileIngestionMethod::Flat;
+    } else if (input == "nar") {
+        return FileIngestionMethod::Recursive;
+    } else {
+        throw UsageError("Unknown file ingestion method '%s', expect `flat` or `nar`");
+    }
+}
+
+
 void dumpPath(
     SourceAccessor & accessor, const CanonPath & path,
     Sink & sink,

diff --git a/src/libutil/file-content-address.hh b/src/libutil/file-content-address.hh
@@ -23,6 +23,14 @@ enum struct FileIngestionMethod : uint8_t {
     Recursive = 1,
 };
 
+/**
+ * Parse a `FileIngestionMethod` by name. Choice of:
+ *
+ *  - `flat`: `FileIngestionMethod::Flat`
+ *  - `nar`: `FileIngestionMethod::Recursive`
+ */
+FileIngestionMethod parseFileIngestionMethod(std::string_view input);
+
 /**
  * Dump a serialization of the given file system object.
  */

diff --git a/src/nix/add-to-store.cc b/src/nix/add-to-store.cc
@@ -6,17 +6,6 @@
 
 using namespace nix;
 
-static FileIngestionMethod parseIngestionMethod(std::string_view input)
-{
-    if (input == "flat") {
-        return FileIngestionMethod::Flat;
-    } else if (input == "nar") {
-        return FileIngestionMethod::Recursive;
-    } else {
-        throw UsageError("Unknown hash mode '%s', expect `flat` or `nar`");
-    }
-}
-
 struct CmdAddToStore : MixDryRun, StoreCommand
 {
     Path path;
@@ -37,21 +26,7 @@ struct CmdAddToStore : MixDryRun, StoreCommand
             .handler = {&namePart},
         });
 
-        addFlag({
-            .longName  = "mode",
-            .description = R"(
-    How to compute the hash of the input.
-    One of:
-
-    - `nar` (the default): Serialises the input as an archive (following the [_Nix Archive Format_](https://edolstra.github.io/pubs/phd-thesis.pdf#page=101)) and passes that to the hash function.
-
-    - `flat`: Assumes that the input is a single file and directly passes it to the hash function;
-            )",
-            .labels = {"hash-mode"},
-            .handler = {[this](std::string s) {
-                this->caMethod = parseIngestionMethod(s);
-            }},
-        });
+        addFlag(Flag::mkFileIngestionMethodFlag(&caMethod));
 
         addFlag(Flag::mkHashAlgoFlag(&hashAlgo));
     }
@@ -76,7 +51,6 @@ struct CmdAddToStore : MixDryRun, StoreCommand
 
 struct CmdAdd : CmdAddToStore
 {
-
     std::string description() override
     {
         return "Add a file or directory to the Nix store";

diff --git a/src/nix/hash.cc b/src/nix/hash.cc
@@ -19,47 +19,12 @@ struct CmdHashBase : Command
     FileIngestionMethod mode;
     HashFormat hashFormat = HashFormat::SRI;
     bool truncate = false;
-    HashAlgorithm ha = HashAlgorithm::SHA256;
+    HashAlgorithm hashAlgo = HashAlgorithm::SHA256;
     std::vector<std::string> paths;
     std::optional<std::string> modulus;
 
     explicit CmdHashBase(FileIngestionMethod mode) : mode(mode)
     {
-        addFlag({
-            .longName = "sri",
-            .description = "Print the hash in SRI format.",
-            .handler = {&hashFormat, HashFormat::SRI},
-        });
-
-        addFlag({
-            .longName = "base64",
-            .description = "Print the hash in base-64 format.",
-            .handler = {&hashFormat, HashFormat::Base64},
-        });
-
-        addFlag({
-            .longName = "base32",
-            .description = "Print the hash in base-32 (Nix-specific) format.",
-            .handler = {&hashFormat, HashFormat::Nix32},
-        });
-
-        addFlag({
-            .longName = "base16",
-            .description = "Print the hash in base-16 format.",
-            .handler = {&hashFormat, HashFormat::Base16},
-        });
-
-        addFlag(Flag::mkHashAlgoFlag("type", &ha));
-
-        #if 0
-        addFlag({
-            .longName = "modulo",
-            .description = "Compute the hash modulo the specified string.",
-            .labels = {"modulus"},
-            .handler = {&modulus},
-        });
-        #endif\
-
         expectArgs({
             .label = "paths",
             .handler = {&paths},
@@ -85,9 +50,9 @@ struct CmdHashBase : Command
 
             std::unique_ptr<AbstractHashSink> hashSink;
             if (modulus)
-                hashSink = std::make_unique<HashModuloSink>(ha, *modulus);
+                hashSink = std::make_unique<HashModuloSink>(hashAlgo, *modulus);
             else
-                hashSink = std::make_unique<HashSink>(ha);
+                hashSink = std::make_unique<HashSink>(hashAlgo);
 
             PosixSourceAccessor accessor;
             dumpPath(accessor, CanonPath::fromCwd(path), *hashSink, mode);
@@ -99,15 +64,78 @@ struct CmdHashBase : Command
     }
 };
 
+/**
+ * `nix hash path`
+ */
+struct CmdHashPath : CmdHashBase
+{
+    CmdHashPath()
+        : CmdHashBase(FileIngestionMethod::Recursive)
+    {
+        addFlag(Flag::mkHashAlgoFlag(&hashAlgo));
+        addFlag(Flag::mkFileIngestionMethodFlag(&mode));
+        addFlag(Args::Flag::mkHashFormatFlagWithDefault(&hashFormat));
+        #if 0
+        addFlag({
+            .longName = "modulo",
+            .description = "Compute the hash modulo the specified string.",
+            .labels = {"modulus"},
+            .handler = {&modulus},
+        });
+        #endif
+    }
+};
+
+/**
+ * For deprecated `nix hash file`
+ *
+ * Deprecation Issue: https://github.com/NixOS/nix/issues/8876
+ */
+struct CmdHashFile : CmdHashBase
+{
+    CmdHashFile()
+        : CmdHashBase(FileIngestionMethod::Flat)
+    {
+        addFlag({
+            .longName = "sri",
+            .description = "Print the hash in SRI format.",
+            .handler = {&hashFormat, HashFormat::SRI},
+        });
+
+        addFlag({
+            .longName = "base64",
+            .description = "Print the hash in base-64 format.",
+            .handler = {&hashFormat, HashFormat::Base64},
+        });
+
+        addFlag({
+            .longName = "base32",
+            .description = "Print the hash in base-32 (Nix-specific) format.",
+            .handler = {&hashFormat, HashFormat::Nix32},
+        });
+
+        addFlag({
+            .longName = "base16",
+            .description = "Print the hash in base-16 format.",
+            .handler = {&hashFormat, HashFormat::Base16},
+        });
+
+        addFlag(Flag::mkHashAlgoFlag("type", &hashAlgo));
+    }
+};
+
+/**
+ * For deprecated `nix hash to-*`
+ */
 struct CmdToBase : Command
 {
     HashFormat hashFormat;
-    std::optional<HashAlgorithm> ht;
+    std::optional<HashAlgorithm> hashAlgo;
     std::vector<std::string> args;
 
     CmdToBase(HashFormat hashFormat) : hashFormat(hashFormat)
     {
-        addFlag(Flag::mkHashAlgoOptFlag("type", &ht));
+        addFlag(Flag::mkHashAlgoOptFlag("type", &hashAlgo));
         expectArgs("strings", &args);
     }
 
@@ -124,7 +152,7 @@ struct CmdToBase : Command
     {
         warn("The old format conversion sub commands of `nix hash` where deprecated in favor of `nix hash convert`.");
         for (auto s : args)
-            logger->cout(Hash::parseAny(s, ht).to_string(hashFormat, hashFormat == HashFormat::SRI));
+            logger->cout(Hash::parseAny(s, hashAlgo).to_string(hashFormat, hashFormat == HashFormat::SRI));
     }
 };
 
@@ -182,8 +210,8 @@ struct CmdHash : NixMultiCommand
             "hash",
             {
                 {"convert", []() { return make_ref<CmdHashConvert>();}},
-                {"file", []() { return make_ref<CmdHashBase>(FileIngestionMethod::Flat);; }},
-                {"path", []() { return make_ref<CmdHashBase>(FileIngestionMethod::Recursive); }},
+                {"path", []() { return make_ref<CmdHashPath>(); }},
+                {"file", []() { return make_ref<CmdHashFile>(); }},
                 {"to-base16", []() { return make_ref<CmdToBase>(HashFormat::Base16); }},
                 {"to-base32", []() { return make_ref<CmdToBase>(HashFormat::Nix32); }},
                 {"to-base64", []() { return make_ref<CmdToBase>(HashFormat::Base64); }},
@@ -207,7 +235,7 @@ static int compatNixHash(int argc, char * * argv)
     // Wait until `nix hash convert` is not hidden behind experimental flags anymore.
     // warn("`nix-hash` has been deprecated in favor of `nix hash convert`.");
 
-    std::optional<HashAlgorithm> ha;
+    std::optional<HashAlgorithm> hashAlgo;
     bool flat = false;
     HashFormat hashFormat = HashFormat::Base16;
     bool truncate = false;
@@ -227,7 +255,7 @@ static int compatNixHash(int argc, char * * argv)
         else if (*arg == "--truncate") truncate = true;
         else if (*arg == "--type") {
             std::string s = getArg(*arg, arg, end);
-            ha = parseHashAlgo(s);
+            hashAlgo = parseHashAlgo(s);
         }
         else if (*arg == "--to-base16") {
             op = opTo;
@@ -254,8 +282,8 @@ static int compatNixHash(int argc, char * * argv)
 
     if (op == opHash) {
         CmdHashBase cmd(flat ? FileIngestionMethod::Flat : FileIngestionMethod::Recursive);
-        if (!ha.has_value()) ha = HashAlgorithm::MD5;
-        cmd.ha = ha.value();
+        if (!hashAlgo.has_value()) hashAlgo = HashAlgorithm::MD5;
+        cmd.hashAlgo = hashAlgo.value();
         cmd.hashFormat = hashFormat;
         cmd.truncate = truncate;
         cmd.paths = ss;
@@ -265,7 +293,7 @@ static int compatNixHash(int argc, char * * argv)
     else {
         CmdToBase cmd(hashFormat);
         cmd.args = ss;
-        if (ha.has_value()) cmd.ht = ha;
+        if (hashAlgo.has_value()) cmd.hashAlgo = hashAlgo;
         cmd.run();
     }
 

diff --git a/tests/functional/hash.sh b/tests/functional/hash.sh
@@ -12,6 +12,11 @@ try () {
         echo "try nix hash: hash $1, expected $3, got $hash"
         exit 1
     fi
+    hash="$(nix hash path --mode flat ${FORMAT_FLAG-} --type "$1" "$TEST_ROOT/vector")"
+    if ! (( "${NO_TEST_NIX_COMMAND-}" )) && test "$hash" != "$3"; then
+        echo "try nix hash: hash $1, expected $3, got $hash"
+        exit 1
+    fi
 }
 
 FORMAT_FLAG=--base16