Add git file ingestion method

src/libexpr/primops.cc

@@ -725,8 +725,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
         if (!jsonObject) drv.env["out"] = state.store->printStorePath(outPath);
         drv.outputs.insert_or_assign("out", DerivationOutput {
             std::move(outPath),
-            (ingestionMethod == FileIngestionMethod::Recursive ? "r:" : "")
-                + printHashType(h.type),
+            ingestionMethodPrefix(ingestionMethod) + printHashType(h.type),
             h.to_string(Base16, false),
         });
     }

src/libstore/binary-cache-store.cc

@@ -339,6 +339,8 @@ StorePath BinaryCacheStore::addToStore(const string & name, const Path & srcPath
     if (method == FileIngestionMethod::Recursive) {
         dumpPath(srcPath, sink, filter);
         h = hashString(hashAlgo, *sink.s);
+    } else if (method == FileIngestionMethod::Git) {
+        throw Error("cannot add to binary cache store using the git file ingestion method");
     } else {
         auto s = readFile(srcPath);
         dumpString(s, sink);

src/libstore/derivations.cc

@@ -9,13 +9,16 @@
 namespace nix {
 
 
-void DerivationOutput::parseHashInfo(FileIngestionMethod & recursive, Hash & hash) const
+void DerivationOutput::parseHashInfo(FileIngestionMethod & method, Hash & hash) const
 {
-    recursive = FileIngestionMethod::Flat;
+    method = FileIngestionMethod::Flat;
     string algo = hashAlgo;
 
     if (string(algo, 0, 2) == "r:") {
-        recursive = FileIngestionMethod::Recursive;
+        method = FileIngestionMethod::Recursive;
+        algo = string(algo, 2);
+    } else if (string(algo, 0, 4) == "git:") {
+        method = FileIngestionMethod::Git;
         algo = string(algo, 2);
     }
 

src/libstore/derivations.hh

@@ -22,7 +22,7 @@ struct DerivationOutput
         , hashAlgo(std::move(hashAlgo))
         , hash(std::move(hash))
     { }
-    void parseHashInfo(FileIngestionMethod & recursive, Hash & hash) const;
+    void parseHashInfo(FileIngestionMethod & method, Hash & hash) const;
 };
 
 typedef std::map<string, DerivationOutput> DerivationOutputs;

src/libstore/ipfs.cc

@@ -0,0 +1,61 @@
+#include "binary-cache-store.hh"
+
+namespace nix {
+
+class IpfsStore : public BinaryCacheStore
+{
+    Path daemonUri;
+
+public:
+
+    IpfsStore(
+        const Params & params, const Path & _daemonUri)
+        : BinaryCacheStore(params)
+        , daemonUri(_daemonUri)
+    {
+        if (daemonUri.back() == '/')
+            daemonUri.pop_back();
+    }
+
+    std::string getUri() override
+    {
+        return daemonUri;
+    }
+
+    void init() override
+    {
+    }
+
+    bool fileExists(const std::string & path) override
+    {
+        return false;
+    }
+
+    void upsertFile(const std::string & path,
+        const std::string & data,
+        const std::string & mimeType) override
+    {
+    }
+
+    void getFile(const std::string & path, Sink & sink) override
+    {
+    }
+
+    void getFile(const std::string & path, Callback<std::shared_ptr<std::string>> callback) noexcept override
+    {
+    }
+
+};
+
+static RegisterStoreImplementation regStore([](
+    const std::string & uri, const Store::Params & params)
+    -> std::shared_ptr<Store>
+{
+    if (std::string(uri, 0, 12) != "ipfs+http://")
+        return 0;
+    auto store = std::make_shared<IpfsStore>(params, std::string(uri, 5));
+    store->init();
+    return store;
+});
+
+}

src/libstore/path.hh

@@ -74,10 +74,23 @@ const size_t storePathHashLen = 32; // i.e. 160 bits
 const std::string drvExtension = ".drv";
 
 enum struct FileIngestionMethod : uint8_t {
-    Flat = false,
-    Recursive = true
+    Flat,
+    Recursive,
+    Git
 };
 
+inline std::string ingestionMethodPrefix(FileIngestionMethod method) {
+    switch (method) {
+    case FileIngestionMethod::Flat:
+        return "";
+    case FileIngestionMethod::Recursive:
+        return "r:";
+    case FileIngestionMethod::Git:
+        return "git:";
+    }
+    throw;
+}
+
 struct StorePathWithOutputs
 {
     StorePath path;

src/libstore/remote-store.cc

@@ -488,6 +488,8 @@ StorePath RemoteStore::addToStore(const string & name, const Path & _srcPath,
 {
     if (repair) throw Error("repairing is not supported when building through the Nix daemon");
 
+    if (method == FileIngestionMethod::Git) throw Error("cannot remotely add to store using the git file ingestion method");
+
     auto conn(getConnection());
 
     Path srcPath(absPath(_srcPath));

src/libstore/store-api.cc

@@ -118,8 +118,8 @@ string storePathToHash(const Path & path)
        for paths copied by addToStore() or produced by fixed-output
        derivations:
          the string "fixed:out:<rec><algo>:<hash>:", where
-           <rec> = "r:" for recursive (path) hashes, or "" for flat
-             (file) hashes
+           <rec> = "r:" for recursive (path) hashes, "git:" for git
+             paths, or "" for flat (file) hashes
            <algo> = "md5", "sha1" or "sha256"
            <hash> = base-16 representation of the path or flat hash of
              the contents of the path (or expected contents of the
@@ -172,20 +172,20 @@ static std::string makeType(
 
 
 StorePath Store::makeFixedOutputPath(
-    FileIngestionMethod recursive,
+    FileIngestionMethod method,
     const Hash & hash,
     std::string_view name,
     const StorePathSet & references,
     bool hasSelfReference) const
 {
-    if (hash.type == htSHA256 && recursive == FileIngestionMethod::Recursive) {
+    if (hash.type == htSHA256 && method == FileIngestionMethod::Recursive) {
         return makeStorePath(makeType(*this, "source", references, hasSelfReference), hash, name);
     } else {
         assert(references.empty());
         return makeStorePath("output:out",
             hashString(htSHA256,
                 "fixed:out:"
-                + (recursive == FileIngestionMethod::Recursive ? (string) "r:" : "")
+                + ingestionMethodPrefix(method)
                 + hash.to_string(Base16) + ":"),
             name);
     }
@@ -787,15 +787,19 @@ bool ValidPathInfo::isContentAddressed(const Store & store) const
     }
 
     else if (hasPrefix(ca, "fixed:")) {
-        FileIngestionMethod recursive { ca.compare(6, 2, "r:") == 0 };
-        Hash hash(std::string(ca, recursive == FileIngestionMethod::Recursive ? 8 : 6));
+        FileIngestionMethod method = FileIngestionMethod::Flat;
+        if (ca.compare(6, 2, "r:") == 0)
+            method = FileIngestionMethod::Recursive;
+        else if (ca.compare(6, 4, "git:") == 0)
+            method = FileIngestionMethod::Git;
+        Hash hash(std::string(ca, 6 + ingestionMethodPrefix(method).length()));
         auto refs = cloneStorePathSet(references);
         bool hasSelfReference = false;
         if (refs.count(path)) {
             hasSelfReference = true;
             refs.erase(path);
         }
-        if (store.makeFixedOutputPath(recursive, hash, path.name(), refs, hasSelfReference) == path)
+        if (store.makeFixedOutputPath(method, hash, path.name(), refs, hasSelfReference) == path)
             return true;
         else
             warn();
@@ -832,11 +836,9 @@ Strings ValidPathInfo::shortRefs() const
 }
 
 
-std::string makeFixedOutputCA(FileIngestionMethod recursive, const Hash & hash)
+std::string makeFixedOutputCA(FileIngestionMethod method, const Hash & hash)
 {
-    return "fixed:"
-        + (recursive == FileIngestionMethod::Recursive ? (std::string) "r:" : "")
-        + hash.to_string();
+    return "fixed:" + ingestionMethodPrefix(method) + hash.to_string();
 }
 
 

src/nix-store/nix-store.cc

@@ -174,10 +174,10 @@ static void opAdd(Strings opFlags, Strings opArgs)
    store. */
 static void opAddFixed(Strings opFlags, Strings opArgs)
 {
-    auto recursive = FileIngestionMethod::Flat;
+    auto method = FileIngestionMethod::Flat;
 
     for (auto & i : opFlags)
-        if (i == "--recursive") recursive = FileIngestionMethod::Recursive;
+        if (i == "--recursive") method = FileIngestionMethod::Recursive;
         else throw UsageError(format("unknown flag '%1%'") % i);
 
     if (opArgs.empty())
@@ -187,17 +187,17 @@ static void opAddFixed(Strings opFlags, Strings opArgs)
     opArgs.pop_front();
 
     for (auto & i : opArgs)
-        cout << fmt("%s\n", store->printStorePath(store->addToStore(std::string(baseNameOf(i)), i, recursive, hashAlgo)));
+        cout << fmt("%s\n", store->printStorePath(store->addToStore(std::string(baseNameOf(i)), i, method, hashAlgo)));
 }
 
 
 /* Hack to support caching in `nix-prefetch-url'. */
 static void opPrintFixedPath(Strings opFlags, Strings opArgs)
 {
-    auto recursive = FileIngestionMethod::Flat;
+    auto method = FileIngestionMethod::Flat;
 
     for (auto i : opFlags)
-        if (i == "--recursive") recursive = FileIngestionMethod::Recursive;
+        if (i == "--recursive") method = FileIngestionMethod::Recursive;
         else throw UsageError(format("unknown flag '%1%'") % i);
 
     if (opArgs.size() != 3)
@@ -208,7 +208,7 @@ static void opPrintFixedPath(Strings opFlags, Strings opArgs)
     string hash = *i++;
     string name = *i++;
 
-    cout << fmt("%s\n", store->printStorePath(store->makeFixedOutputPath(recursive, Hash(hash, hashAlgo), name)));
+    cout << fmt("%s\n", store->printStorePath(store->makeFixedOutputPath(method, Hash(hash, hashAlgo), name)));
 }