This simplifies code so that references to r: come from
ingestionMethodPrefix.

this is more precise

…it-objects-develop

Hopefully we can instead pass arguments like Hydra does, soon.

This matches what we want for blobs.

Trees are still in progress - we need a way to symlink to other
objects, using that to determine ca.

This is really bad and dangerous! But Git migration to sha256 is still
a ways away:

https://lwn.net/Articles/811068/

So we need to allow it for the time being.

We need access to other things in the store. This is kind of dangerous
though if things are added in the wrong order�.

This is needed to create files based on git permissions

This updates the remote protocol to try to handle sha1 hashes.

This is more direct.

We need both to properly mess with the file system. storeDir goes into
the hash while realStoreDir is what we read & write to.

Need to use the htSHA1 we were given, don’t recompute.

this makes maintanence easier

This reverts commit 7b6186d.

narHash is the hash of the nar, not the git objects.

We need to dump path and dump git here so that the hashes match what
is expected elsewhere.

This should always use sha1 hash type, but we want to make sure the
caller knows that. So just throw an error instead of ignoring hashAlgo
on Git ingestion.

symlinks should be relative so that they look like:

  ../s5c0hnz9qfnpnn1bszfxicgz21d1fam3-dummy3

instead of

  /build/nix-test/store/s5c0hnz9qfnpnn1bszfxicgz21d1fam3-dummy3

This way our hashes will work with any real store dir. Note that
/nix/store is still embedded in the store entry function.

this shouldn’t be needed - FdSink handles this for us.

Symlinks are resolved in the nar format so we end up with references
to the real store dir. Copying avoids this and gives us a stable hash.

Also update the ParseSink api with two methods:

  - copyFile
  - copyDirectory

both are needed to properly implement git parsing.

libc++fs isn’t alway available

Add git add-to-store support for Nix

…no-hash-type-unknown

…-hash-type-unknown

Remove `HashType::Unknown`

Handles the treeHash attr in the Git fetcher.

This can be used like:

  builtins.fetchTree {
    type = "git";
    url = "https://github.com/nixos/nix.git";
    treeHash = "0674cab54e1226d8e1e1d04572f07c5296edc862";
  }

Nix stores tree hash as the content hash in the store so that fetched
objects are deduped. This uses the Git file ingestion method, which
converts the files into git objects for hashing.

we need to keep this in vector form so that we don’t accidentally skip
strings starting with 0x00.

git trees can have objects starting with “.” and other cases that Nix
store names can’t have. To avoid having to create some escaping
format, just use git for the name everywhere. The tree object has the
real name.

this should just be 4000, not 04000.

test/ should come *after* test.sh

see http://git.661346.n2.nabble.com/In-tree-object-Must-the-td7446900.html#a7447657

…to fetchgit

Make fetchGit/fetchTree use Git file ingestion

this uses the treeHash to fetch a created git object

based on fetchGit.sh test

Add test for fetchTree

…objects-develop

Add test for git submodules in fetchTree

…-objects-develop

`addToStoreFromDump` would use the CA-specific method.

builtins.fetch* aren’t technically derivations, so they never got
substituted. To work around this, we can try to substitute this store
path during evaluation. This can happen any time a hash is provided.

Updated to be closer to how the flakes branch works.

This is disabled automatically when we’re offline.

Support substituting in fetchGit

to put in a set, we need an ordering

…-path-or-ca

…-path-or-ca

…-path-or-ca

…ix into store-path-or-ca

LegacyContentAddress used for all other usages