mirror of
https://github.com/NixOS/nix
synced 2025-07-05 20:41:47 +02:00
cc24766fa6
For example, instead of doing
#include "nix/store-config.hh"
#include "nix/derived-path.hh"
Now do
#include "nix/store/config.hh"
#include "nix/store/derived-path.hh"
This was originally planned in the issue, and also recent requested by
Eelco.
Most of the change is purely mechanical. There is just one small
additional issue. See how, in the example above, we took this
opportunity to also turn `<comp>-config.hh` into `<comp>/config.hh`.
Well, there was already a `nix/util/config.{cc,hh}`. Even though there
is not a public configuration header for libutil (which also would be
called `nix/util/config.{cc,hh}`) that's still confusing, To avoid any
such confusion, we renamed that to `nix/util/configuration.{cc,hh}`.
Finally, note that the libflake headers already did this, so we didn't
need to do anything to them. We wouldn't want to mistakenly get
`nix/flake/flake/flake.hh`!
Progress on #7876
133 lines
3.2 KiB
C++
133 lines
3.2 KiB
C++
#include "nix/util/file-content-address.hh"
|
|
#include "nix/util/archive.hh"
|
|
#include "nix/util/git.hh"
|
|
#include "nix/util/source-path.hh"
|
|
|
|
namespace nix {
|
|
|
|
static std::optional<FileSerialisationMethod> parseFileSerialisationMethodOpt(std::string_view input)
|
|
{
|
|
if (input == "flat") {
|
|
return FileSerialisationMethod::Flat;
|
|
} else if (input == "nar") {
|
|
return FileSerialisationMethod::NixArchive;
|
|
} else {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
FileSerialisationMethod parseFileSerialisationMethod(std::string_view input)
|
|
{
|
|
auto ret = parseFileSerialisationMethodOpt(input);
|
|
if (ret)
|
|
return *ret;
|
|
else
|
|
throw UsageError("Unknown file serialiation method '%s', expect `flat` or `nar`");
|
|
}
|
|
|
|
|
|
FileIngestionMethod parseFileIngestionMethod(std::string_view input)
|
|
{
|
|
if (input == "git") {
|
|
return FileIngestionMethod::Git;
|
|
} else {
|
|
auto ret = parseFileSerialisationMethodOpt(input);
|
|
if (ret)
|
|
return static_cast<FileIngestionMethod>(*ret);
|
|
else
|
|
throw UsageError("Unknown file ingestion method '%s', expect `flat`, `nar`, or `git`");
|
|
}
|
|
}
|
|
|
|
|
|
std::string_view renderFileSerialisationMethod(FileSerialisationMethod method)
|
|
{
|
|
switch (method) {
|
|
case FileSerialisationMethod::Flat:
|
|
return "flat";
|
|
case FileSerialisationMethod::NixArchive:
|
|
return "nar";
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
|
|
std::string_view renderFileIngestionMethod(FileIngestionMethod method)
|
|
{
|
|
switch (method) {
|
|
case FileIngestionMethod::Flat:
|
|
case FileIngestionMethod::NixArchive:
|
|
return renderFileSerialisationMethod(
|
|
static_cast<FileSerialisationMethod>(method));
|
|
case FileIngestionMethod::Git:
|
|
return "git";
|
|
default:
|
|
unreachable();
|
|
}
|
|
}
|
|
|
|
|
|
void dumpPath(
|
|
const SourcePath & path,
|
|
Sink & sink,
|
|
FileSerialisationMethod method,
|
|
PathFilter & filter)
|
|
{
|
|
switch (method) {
|
|
case FileSerialisationMethod::Flat:
|
|
path.readFile(sink);
|
|
break;
|
|
case FileSerialisationMethod::NixArchive:
|
|
path.dumpPath(sink, filter);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void restorePath(
|
|
const Path & path,
|
|
Source & source,
|
|
FileSerialisationMethod method,
|
|
bool startFsync)
|
|
{
|
|
switch (method) {
|
|
case FileSerialisationMethod::Flat:
|
|
writeFile(path, source, 0666, startFsync);
|
|
break;
|
|
case FileSerialisationMethod::NixArchive:
|
|
restorePath(path, source, startFsync);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
HashResult hashPath(
|
|
const SourcePath & path,
|
|
FileSerialisationMethod method, HashAlgorithm ha,
|
|
PathFilter & filter)
|
|
{
|
|
HashSink sink { ha };
|
|
dumpPath(path, sink, method, filter);
|
|
return sink.finish();
|
|
}
|
|
|
|
|
|
std::pair<Hash, std::optional<uint64_t>> hashPath(
|
|
const SourcePath & path,
|
|
FileIngestionMethod method, HashAlgorithm ht,
|
|
PathFilter & filter)
|
|
{
|
|
switch (method) {
|
|
case FileIngestionMethod::Flat:
|
|
case FileIngestionMethod::NixArchive: {
|
|
auto res = hashPath(path, (FileSerialisationMethod) method, ht, filter);
|
|
return {res.first, {res.second}};
|
|
}
|
|
case FileIngestionMethod::Git:
|
|
return {git::dumpHash(ht, path, filter).hash, std::nullopt};
|
|
}
|
|
assert(false);
|
|
}
|
|
|
|
}
|