mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(nix/utils): remove predicates based on symlink heuristic

Browse source 
Due to [nix#6579] the heuristic which allowed us to determine if a
symlink points to a directory is not reliable – if restrict-eval is
enabled it _will_ return wrong results. Until upstream resolves
this (and we backport the patch) it is probably best to not expose this
functionality at all.

[nix#6579]: https://github.com/NixOS/nix/issues/6579

Change-Id: Id847c794bb279be909c5426953c4fe13c2493343
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5761
Tested-by: BuildkiteCI
Autosubmit: sterni <sternenseemann@systemli.org>
Reviewed-by: tazjin <tazjin@tvl.su>
This commit is contained in:
sterni 2022-05-28 13:28:37 +02:00 committed by clbot
parent c06d47b787
commit a6367b4bdc
2 changed files with 6 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
nix/utils/default.nix
View file

@ -53,13 +53,7 @@ let
* `regular`: is a regular file, always `true` if returned
* `directory`: is a directory, always `true` if returned
* `missing`: path does not exist, always `true` if returned
* `symlink`: path is a symlink, value is a string describing the type
of its realpath which may be either:
* `"directory"`: realpath of the symlink is a directory
* `"regular-or-missing`": realpath of the symlink is either a regular
file or does not exist. Due to limitations of the Nix expression
language, we can't tell which.
* `symlink`: path is a symlink, always `true` if returned
Type: path(-like) -> tag
@ -73,10 +67,10 @@ let
=> { directory = true; }
pathType ./result
=> { symlink = "directory"; }
=> { symlink = true; }
pathType ./link-to-file
=> { symlink = "regular-or-missing"; }
=> { symlink = true; }
pathType /does/not/exist
=> { missing = true; }
@ -90,12 +84,12 @@ let
# Match on the result using //nix/tag
nix.tag.match (nix.utils.pathType ./result) {
symlink = v: "symlink to ${v}";
symlink = _: "symlink";
directory = _: "directory";
regular = _: "regular";
missing = _: "path does not exist";
}
=> "symlink to directory"
=> "symlink"
# Query path type
nix.tag.tagName (pathType /path)
@ -122,11 +116,7 @@ let
isSymlinkDir = builtins.pathExists (path' + "/.");
in
{
${thisPathType} =
/**/
if thisPathType != "symlink" then true
else if isSymlinkDir then "directory"
else "regular-or-missing";
${thisPathType} = true;
};
pathType' = path:
@ -144,21 +134,6 @@ let
*/
isDirectory = path: pathType' path ? directory;
/* Checks whether the given path is a directory or
a symlink to a directory. Throws if the path in
question doesn't exist.
Warning: Does not throw if the target file or
directory doesn't exist, but the symlink does.
Type: path(-like) -> bool
*/
realPathIsDirectory = path:
let
pt = pathType' path;
in
pt ? directory || pt.symlink or null == "directory";
/* Check whether the given path is a regular file.
Throws if the path in question doesn't exist.
@ -179,7 +154,6 @@ in
storePathName
pathType
isDirectory
realPathIsDirectory
isRegularFile
isSymlink
;

31
nix/utils/tests/default.nix
View file

@ -11,7 +11,6 @@ let
inherit (depot.nix.utils)
isDirectory
realPathIsDirectory
isRegularFile
isSymlink
pathType
@ -34,16 +33,6 @@ let
(assertUtilsPred "file not isDirectory"
(isDirectory ./directory/file)
false)
# realPathIsDirectory
(assertUtilsPred "directory realPathIsDirectory"
(realPathIsDirectory ./directory)
true)
(assertUtilsPred "symlink to directory realPathIsDirectory"
(realPathIsDirectory ./symlink-directory)
true)
(assertUtilsPred "realPathIsDirectory resolves chained symlinks"
(realPathIsDirectory ./symlink-symlink-directory)
true)
# isRegularFile
(assertUtilsPred "file isRegularFile"
(isRegularFile ./directory/file)
@ -76,31 +65,12 @@ let
# missing files throw
(assertThrows "isDirectory throws on missing file"
(isDirectory ./does-not-exist))
(assertThrows "realPathIsDirectory throws on missing file"
(realPathIsDirectory ./does-not-exist))
(assertThrows "isRegularFile throws on missing file"
(isRegularFile ./does-not-exist))
(assertThrows "isSymlink throws on missing file"
(isSymlink ./does-not-exist))
]);
symlinkPathTypeTests = it "correctly judges symlinks" [
(assertEq "symlinks to directories are detected correcty"
((pathType ./symlink-directory).symlink or null) "directory")
(assertEq "symlinks to symlinks to directories are detected correctly"
((pathType ./symlink-symlink-directory).symlink or null) "directory")
(assertEq "symlinks to nowhere are not distinguished from files"
((pathType ./missing).symlink or null) "regular-or-missing")
# These tests are commented out because they no longer work with
# restrict-eval turned on.
# (assertEq "symlinks to files are detected-ish"
# ((pathType ./symlink-file).symlink or null) "regular-or-missing")
# (assertEq "symlinks to symlinks to files are detected-ish"
# ((pathType ./symlink-symlink-file).symlink or null) "regular-or-missing")
];
cheddarStorePath =
builtins.unsafeDiscardStringContext depot.tools.cheddar.outPath;
@ -125,6 +95,5 @@ in
runTestsuite "nix.utils" [
pathPredicates
symlinkPathTypeTests
storePathNameTests
]