Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sneak
|
784a7b7a74 | ||
 clawbot
|
6caaff935a | ||
|
clawbot
|
f0b679e9fa |
No files matched your search
@@ -44,7 +44,9 @@ as opposed to a directory, a symlink or a device node. A symlink is a file that
|
||||
holds the path of another file and stands in for it. A device node is a file
|
||||
that stands for a piece of hardware, such as a disk or a terminal. `report`
|
||||
prints the file-level duplicates. `trees` prints the duplicate directory trees.
|
||||
`info` prints the database's path, size and record count.
|
||||
Both cover the whole database, or only the paths given after them, as in
|
||||
`sfdupes report /srv/photos`. `info` prints the database's path, size and record
|
||||
count.
|
||||
|
||||
The database is `/var/lib/sfdupes/db.sqlite` unless `SFDUPES_DATABASE` names
|
||||
another file. The first `scan` creates it.
|
||||
@@ -259,9 +261,9 @@ In order:
|
||||
report.
|
||||
|
||||
```
|
||||
sfdupes scan [--workers N] [-x] [--no-default-excludes] PATH...
|
||||
sfdupes report > dupes.tsv
|
||||
sfdupes trees > dupetrees.tsv
|
||||
sfdupes scan [--workers N] [-x] [--no-default-excludes] [--exclude PATH]... PATH...
|
||||
sfdupes report [PATH...] > dupes.tsv
|
||||
sfdupes trees [PATH...] > dupetrees.tsv
|
||||
sfdupes info
|
||||
sfdupes dwim
|
||||
sfdupes --version
|
||||
@@ -304,6 +306,16 @@ The reference below is also the program's specification.
|
||||
- `--no-default-excludes` (`scan`) lets the walk enter the default excludes.
|
||||
Those are the system and temporary directories the walk otherwise leaves out,
|
||||
such as `/var/tmp` on Linux (see "Rules for the walk").
|
||||
- `--exclude PATH` (`scan`) keeps the walk out of `PATH` and everything below
|
||||
it. `PATH` may be a directory or a file. The flag may be given more than once.
|
||||
The walk knows `PATH` by its device ID and inode number, as it knows the
|
||||
database files (see "Rules for the walk"). So the walk leaves `PATH` out
|
||||
whatever path leads to it. That includes a hard link to a file given as
|
||||
`PATH`. A symlink given as `PATH` excludes its target. An empty `PATH`, as in
|
||||
`--exclude ""`, is a usage error, reported in one line on stderr with exit 2
|
||||
before anything is scanned. A `PATH` that does not exist, or whose real path
|
||||
`scan` cannot find, is a fatal error. So is an operand at or below one (see
|
||||
"Operands").
|
||||
- `--version`, `-v` prints `sfdupes VERSION` (see "Install") to stdout and
|
||||
exits 0. It writes nothing to stderr.
|
||||
- `--help`, `-h`, alone or after a subcommand, prints the help text to stderr
|
||||
@@ -362,6 +374,10 @@ default. An operand may be a directory or a regular file.
|
||||
- An operand that does not exist is a fatal error, and so is a symlink whose
|
||||
target does not exist. `scan` then stops before it walks anything, and exits
|
||||
with code 1.
|
||||
- An operand at or below an `--exclude` path is a fatal error too. The message
|
||||
names the operand and the `--exclude` path. `scan` compares the operand and
|
||||
each directory above it with the `--exclude` paths by device ID and inode
|
||||
number, not by name.
|
||||
- Each operand is resolved to its real path before the walk, as `realpath`
|
||||
prints it. A relative operand is joined to the working directory as `pwd -P`
|
||||
prints it. Every symlink in the path is then followed. A `..` after a symlink
|
||||
@@ -437,15 +453,16 @@ operands:
|
||||
scanned on different schedules into one database.
|
||||
- The scan keeps every record at or below a path that the walk leaves out for
|
||||
one of these reasons:
|
||||
- it is an `--exclude` path;
|
||||
- it is a default exclude;
|
||||
- it is not on a persistent filesystem;
|
||||
- with `-x`, it is a directory on another filesystem than its operand.
|
||||
|
||||
Such records count as outside the scanned operands. So with `-x`, a
|
||||
filesystem mounted under an operand can be scanned on its own schedule into
|
||||
the same database. An operand may itself lie at or inside such a path, as
|
||||
"Operands" describes. Its walk verifies the records below it, so they are
|
||||
deleted when their files are gone.
|
||||
the same database. An operand may itself lie at or inside such a path, other
|
||||
than an `--exclude` path (see "Operands"). Its walk verifies the records
|
||||
below it, so they are deleted when their files are gone.
|
||||
|
||||
#### Phases
|
||||
|
||||
@@ -544,6 +561,17 @@ walk practical on large or busy storage pools.
|
||||
The path is not counted as skipped. The records below it are kept, as
|
||||
described under "What a scan does to the database".
|
||||
|
||||
- The walk never enters or records an `--exclude` path, nor anything below it.
|
||||
For each one it reaches, `scan` prints a line on stderr naming it:
|
||||
|
||||
```
|
||||
scan: skipped /srv/cache (--exclude)
|
||||
```
|
||||
|
||||
The path is not counted as skipped. The scan keeps the records at and below
|
||||
it, as described under "What a scan does to the database".
|
||||
`--no-default-excludes` does not change this rule.
|
||||
|
||||
- Below an operand, the walk does not enter a default exclude. On Linux, the
|
||||
default excludes hold temporary files and the kernel's view of the running
|
||||
system. They depend on the system, and `sfdupes scan --help` lists those of
|
||||
@@ -618,7 +646,8 @@ from a thread of its own and never blocks the workers.
|
||||
it repeats another or lies under another;
|
||||
- the progress display of each phase (see "Progress"). `scan` prints each
|
||||
warning for a skipped path as it happens. It prints a line the same way for
|
||||
each path left out as a default exclude or as not on a persistent filesystem;
|
||||
each path left out as an `--exclude` path, as a default exclude or as not on a
|
||||
persistent filesystem;
|
||||
- the summary line;
|
||||
- a warning when a report still has the database open as the scan ends (see
|
||||
"Concurrent reads").
|
||||
@@ -659,11 +688,12 @@ and `scan` leaves it ignored.
|
||||
|
||||
### `report` mode
|
||||
|
||||
`report` reads every record from the database. It takes no positional arguments.
|
||||
A positional argument is anything on the command line that is not a flag, such
|
||||
as the paths `scan` takes. `report` never opens a scanned file. It checks that
|
||||
each path in a group still exists, and looks at no other path. The check is
|
||||
`lstat`, the system call that looks up a path without following a symlink:
|
||||
`report` reads every record from the database. It takes optional `PATH`
|
||||
operands. With none, it uses every record. With one or more, it uses only the
|
||||
records at or below them (see "Operands of `report` and `trees`"). `report`
|
||||
never opens a scanned file. It checks that each path in a group still exists,
|
||||
and looks at no other path. It never looks up an operand. The check is `lstat`,
|
||||
the system call that looks up a path without following a symlink:
|
||||
|
||||
- A path is gone when `lstat` finds that it, or a directory above it, does not
|
||||
exist.
|
||||
@@ -695,6 +725,27 @@ with one signature come together, and so do the records of one size. So `report`
|
||||
holds only the duplicate groups of the size it is reading. Once it reaches a
|
||||
smaller size, it writes them, ordered by `first` path.
|
||||
|
||||
#### Operands of `report` and `trees`
|
||||
|
||||
`report` and `trees` take the same `PATH` operands:
|
||||
|
||||
- A record is used when its path is an operand or lies below one. `/srv/photos`
|
||||
covers `/srv/photos/x` but not `/srv/photos2/x`.
|
||||
- The records used are grouped, ordered and totalled as they are without
|
||||
operands. A copy outside the operands is not reported. With copies `/a/f`,
|
||||
`/srv/photos/x` and `/srv/photos/y`, `sfdupes report /srv/photos` prints one
|
||||
row, `/srv/photos/x` and `/srv/photos/y`.
|
||||
- A relative operand is joined to the working directory as `pwd -P` prints it.
|
||||
- Each operand is then cleaned as text, as `realpath -ms` prints it. Its `.`
|
||||
elements and repeated or trailing slashes are dropped. Each `..` drops the
|
||||
element before it.
|
||||
- No operand is looked up on the filesystem. A symlink in an operand is not
|
||||
followed, and an operand need not exist. The records hold real paths (see
|
||||
"Operands" under "`scan` mode"), so an operand that passes through a symlink
|
||||
matches no record.
|
||||
- An operand that matches no record is not an error. The report then has no
|
||||
rows.
|
||||
|
||||
#### Report output format
|
||||
|
||||
The report is TSV (tab-separated values) on stdout. It holds a header line, then
|
||||
@@ -722,7 +773,8 @@ Grouping and ordering use the stored path. The warnings about skipped paths that
|
||||
|
||||
The summary line on stderr gives:
|
||||
|
||||
- the records read;
|
||||
- the records read, which are all the records in the database, with or without
|
||||
operands;
|
||||
- the duplicate groups;
|
||||
- the dupe files, which is the number of rows;
|
||||
- the reclaimable bytes, the sum of `size` over all rows.
|
||||
@@ -733,11 +785,12 @@ report: 14 records read, 4 duplicate groups, 7 dupe files, 10.0 KiB reclaimable
|
||||
|
||||
### `trees` mode
|
||||
|
||||
`trees` reads the same database as `report` and takes no positional arguments.
|
||||
It reports whole duplicate directory trees. Two directories are duplicate trees
|
||||
when they hold the same relative paths, and each path holds a file with the same
|
||||
signature in both. It rebuilds the directory tree from the paths in the records,
|
||||
split on `/`. Like `report`, it never opens a scanned file. It checks only that
|
||||
`trees` reads the same database as `report` and takes the same `PATH` operands
|
||||
(see "Operands of `report` and `trees`"). It reports whole duplicate directory
|
||||
trees. Two directories are duplicate trees when they hold the same relative
|
||||
paths, and each path holds a file with the same signature in both. It rebuilds
|
||||
the directory tree from the paths in the records, split on `/`. Like `report`,
|
||||
it never opens a scanned file and never looks up an operand. It checks only that
|
||||
the directory at the top of each copy still exists, as `report` checks a path.
|
||||
|
||||
Definitions:
|
||||
@@ -765,6 +818,11 @@ Processing:
|
||||
directories that all have the same digest. The parents' group, or an
|
||||
ancestor's, already implies it. A group is always reported when it holds
|
||||
sibling directories, or when its members' parents have different digests.
|
||||
- With operands, `trees` builds the tree from the records it uses. It reports
|
||||
only directories at or below an operand. Any other directory lies above an
|
||||
operand and can hold files that are not used, so its digest does not describe
|
||||
it. Such a directory is never reported and never implies a group of its
|
||||
children.
|
||||
- A directory that is gone is dropped from its group. A group left with fewer
|
||||
than two directories is not reported.
|
||||
- Within a group, paths are sorted in byte order. The first is `first`, and
|
||||
@@ -818,7 +876,8 @@ directory's path is `/`.
|
||||
|
||||
The summary line on stderr gives:
|
||||
|
||||
- the records read;
|
||||
- the records read, which are all the records in the database, with or without
|
||||
operands;
|
||||
- the duplicate-tree groups;
|
||||
- the dupe trees, which is the number of rows;
|
||||
- the reclaimable bytes, the sum of `size` over all rows.
|
||||
@@ -831,7 +890,9 @@ trees: 14 records read, 1 duplicate tree groups, 1 dupe trees, 3.0 KiB reclaimab
|
||||
|
||||
`dwim`, short for "do what I mean", scans a new machine and reports its
|
||||
duplicate trees in one command. It takes no positional arguments and no flags of
|
||||
its own. Like `scan`, it should run as root, so that it can read every file.
|
||||
its own. A positional argument is anything on the command line that is not a
|
||||
flag, such as the paths `scan` takes. Like `scan`, it should run as root, so
|
||||
that it can read every file.
|
||||
|
||||
`dwim` runs what `sfdupes scan /` runs with no flags. The walk skips the default
|
||||
excludes and crosses into other filesystems. `--workers` keeps its default. The
|
||||
@@ -1199,6 +1260,9 @@ showing the count it stopped at.
|
||||
- `1`: a fatal error, a `scan` stopped by `SIGINT` or `SIGTERM`, or a `dwim`
|
||||
stopped by either during its scan. A fatal error is one of these:
|
||||
- an operand that does not exist, or whose real path `scan` cannot find;
|
||||
- an `--exclude` path that does not exist, or whose real path `scan` cannot
|
||||
find;
|
||||
- an operand at or below an `--exclude` path;
|
||||
- a list of mounted filesystems that `scan` cannot read;
|
||||
- another `scan` holding the lock (see "The scan lock");
|
||||
- a database, its directory or its lock file that cannot be created or
|
||||
@@ -1218,7 +1282,8 @@ showing the count it stopped at.
|
||||
`--workers abc`;
|
||||
- `scan` with no operand;
|
||||
- `--workers` below 1;
|
||||
- `report`, `trees`, `info` or `dwim` with a positional argument.
|
||||
- an empty `--exclude` value, as in `--exclude ""`;
|
||||
- `info` or `dwim` with a positional argument.
|
||||
|
||||
A fatal error is reported on stderr, starting with `sfdupes:`. A failed write to
|
||||
stdout, such as a full disk, is reported the same way. Two cases never reach
|
||||
|
||||
@@ -29,6 +29,16 @@
|
||||
Newest first. An entry ends with its date and its issue or branch, where those
|
||||
are known.
|
||||
|
||||
- `report` and `trees` take optional `PATH` operands. With operands, they use
|
||||
only the records at or below them. `trees` then reports only directories at or
|
||||
below an operand. Operands are made absolute and cleaned as text, never looked
|
||||
up on the filesystem (2026-11-11,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/174)
|
||||
- New `scan` flag `--exclude PATH`, which may be repeated. The walk neither
|
||||
enters nor records an excluded path, and keeps the records below it. An
|
||||
operand at or below one is a fatal error (2026-11-11,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/163)
|
||||
|
||||
- `report` and `trees` leave out a copy that was deleted after the scan. Each
|
||||
checks only the copy itself with `lstat`: the file, or the directory at the
|
||||
top of a tree. A group left with one copy is not reported. A missing `scan`
|
||||
|
||||
@@ -359,7 +359,7 @@ func TestRunScanInterrupted(t *testing.T) {
|
||||
dir := buildSmokeTree(t)
|
||||
|
||||
err := runScan(t.Context(), []string{dir}, walkCancelWorkers, false,
|
||||
false)
|
||||
false, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -383,7 +383,7 @@ func TestRunScanInterrupted(t *testing.T) {
|
||||
defer close(done)
|
||||
|
||||
err = runScan(cancelledContext(t), []string{dir}, walkCancelWorkers,
|
||||
false, false)
|
||||
false, false, nil)
|
||||
}()
|
||||
|
||||
awaitReturn(t, done, "runScan")
|
||||
@@ -411,7 +411,7 @@ func TestRunScanInterrupted(t *testing.T) {
|
||||
}
|
||||
|
||||
err = runScan(t.Context(), []string{dir}, walkCancelWorkers, false,
|
||||
false)
|
||||
false, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -437,7 +437,7 @@ func TestRunScanInterruptedMidHash(t *testing.T) {
|
||||
dir := buildWalkCancelTree(t)
|
||||
|
||||
err := runScan(newWalkClock(hashCancelAtDone), []string{dir},
|
||||
walkCancelWorkers, false, false)
|
||||
walkCancelWorkers, false, false, nil)
|
||||
if !errors.Is(err, errInterrupted) {
|
||||
t.Fatalf("runScan interrupted mid-hash = %v, want %v",
|
||||
err, errInterrupted)
|
||||
|
||||
+55
-15
@@ -10,6 +10,7 @@ import (
|
||||
"os"
|
||||
"runtime"
|
||||
"runtime/debug"
|
||||
"slices"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
@@ -31,6 +32,13 @@ const (
|
||||
cmdDwim = "dwim"
|
||||
)
|
||||
|
||||
// operandsHelp explains the PATH operands of report and trees in their
|
||||
// help.
|
||||
const operandsHelp = "With PATH operands, only the records at or " +
|
||||
"below them are used. A relative PATH is joined to the working " +
|
||||
"directory. No PATH is looked up on the filesystem, so a symlink in " +
|
||||
"one is not followed."
|
||||
|
||||
// errNoSubcommand is returned by the root command when it is invoked
|
||||
// without a subcommand. That is a usage error, and the usage text
|
||||
// cobra prints for it is the whole message.
|
||||
@@ -40,6 +48,11 @@ var errNoSubcommand = errors.New("no subcommand")
|
||||
// below 1.
|
||||
var errWorkersBelowOne = errors.New("--workers must be at least 1")
|
||||
|
||||
// errEmptyExcludeValue is the usage error for an empty scan --exclude
|
||||
// value, as from --exclude "$DIR" with DIR unset. Taken as a path, it
|
||||
// would name the working directory.
|
||||
var errEmptyExcludeValue = errors.New("--exclude must not be empty")
|
||||
|
||||
// Version is the build version, injected at link time via -ldflags
|
||||
// (see the Makefile); empty when the linker set none, as for a binary
|
||||
// built by go install. buildVersion turns it into what --version prints.
|
||||
@@ -161,20 +174,24 @@ func newRootCommand(stdout, stderr io.Writer) *cobra.Command {
|
||||
"print the version to stdout")
|
||||
|
||||
reportCmd := &cobra.Command{
|
||||
Use: cmdReport,
|
||||
Use: cmdReport + " [PATH...]",
|
||||
Short: "Read the scan database and print the file-level duplicates report",
|
||||
Args: cobra.NoArgs,
|
||||
RunE: runE(func(ctx context.Context, _ []string) error {
|
||||
return runReport(ctx, stdout)
|
||||
Long: "Read the scan database and print the file-level duplicates " +
|
||||
"report.\n\n" + operandsHelp,
|
||||
Args: cobra.ArbitraryArgs,
|
||||
RunE: runE(func(ctx context.Context, args []string) error {
|
||||
return runReport(ctx, args, stdout)
|
||||
}),
|
||||
}
|
||||
|
||||
treesCmd := &cobra.Command{
|
||||
Use: cmdTrees,
|
||||
Use: cmdTrees + " [PATH...]",
|
||||
Short: "Read the scan database and print the duplicate-tree report",
|
||||
Args: cobra.NoArgs,
|
||||
RunE: runE(func(ctx context.Context, _ []string) error {
|
||||
return runTrees(ctx, stdout)
|
||||
Long: "Read the scan database and print the duplicate-tree " +
|
||||
"report.\n\n" + operandsHelp,
|
||||
Args: cobra.ArbitraryArgs,
|
||||
RunE: runE(func(ctx context.Context, args []string) error {
|
||||
return runTrees(ctx, args, stdout)
|
||||
}),
|
||||
}
|
||||
|
||||
@@ -201,21 +218,23 @@ func newRootCommand(stdout, stderr io.Writer) *cobra.Command {
|
||||
return root
|
||||
}
|
||||
|
||||
// newScanCommand builds the scan subcommand, with its --workers, -x and
|
||||
// --no-default-excludes flags. Its help lists the default excludes of
|
||||
// the system it runs on, and the filesystem types it never records
|
||||
// anything on.
|
||||
// newScanCommand builds the scan subcommand, with its --workers, -x,
|
||||
// --no-default-excludes and --exclude flags. Its help lists the default
|
||||
// excludes of the system it runs on, and the filesystem types it never
|
||||
// records anything on.
|
||||
func newScanCommand() *cobra.Command {
|
||||
var (
|
||||
scanWorkers int
|
||||
scanOneFS bool
|
||||
scanNoDefaultExcludes bool
|
||||
scanExclude []string
|
||||
)
|
||||
|
||||
short := "Walk trees and synchronize the scan database"
|
||||
|
||||
scanCmd := &cobra.Command{
|
||||
Use: cmdScan + " [--workers N] [-x] [--no-default-excludes] PATH...",
|
||||
Use: cmdScan + " [--workers N] [-x] [--no-default-excludes] " +
|
||||
"[--exclude PATH]... PATH...",
|
||||
// The Use line already names every flag, so cobra must not
|
||||
// append its generic "[flags]" to it.
|
||||
DisableFlagsInUseLine: true,
|
||||
@@ -223,14 +242,19 @@ func newScanCommand() *cobra.Command {
|
||||
Long: short + ".\n\n" + defaultExcludesHelp(runtime.GOOS),
|
||||
Args: cobra.MinimumNArgs(1),
|
||||
PreRunE: func(cmd *cobra.Command, _ []string) error {
|
||||
return checkScanWorkers(cmd, scanWorkers)
|
||||
err := checkScanWorkers(cmd, scanWorkers)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return rejectEmptyExcludeValue(cmd, scanExclude)
|
||||
},
|
||||
RunE: runE(func(ctx context.Context, args []string) error {
|
||||
ctx, stop := interruptContext(ctx)
|
||||
defer stop()
|
||||
|
||||
return runScan(ctx, args, scanWorkers, scanOneFS,
|
||||
scanNoDefaultExcludes)
|
||||
scanNoDefaultExcludes, scanExclude)
|
||||
}),
|
||||
}
|
||||
scanCmd.Flags().IntVar(&scanWorkers, "workers", runtime.NumCPU(),
|
||||
@@ -239,6 +263,10 @@ func newScanCommand() *cobra.Command {
|
||||
"do not cross filesystem boundaries")
|
||||
scanCmd.Flags().BoolVar(&scanNoDefaultExcludes, "no-default-excludes",
|
||||
false, "enter the default excludes, the paths listed above")
|
||||
// A string array, not a slice, so a comma in a path is not a
|
||||
// separator.
|
||||
scanCmd.Flags().StringArrayVar(&scanExclude, "exclude", nil,
|
||||
"never enter or record `PATH` or anything below it; repeatable")
|
||||
|
||||
return scanCmd
|
||||
}
|
||||
@@ -256,6 +284,18 @@ func checkScanWorkers(cmd *cobra.Command, workers int) error {
|
||||
return fmt.Errorf("%w, got %d", errWorkersBelowOne, workers)
|
||||
}
|
||||
|
||||
// rejectEmptyExcludeValue rejects an empty scan --exclude value. That
|
||||
// is a usage error reported in one line, as for --workers below 1.
|
||||
func rejectEmptyExcludeValue(cmd *cobra.Command, excludePaths []string) error {
|
||||
if !slices.Contains(excludePaths, "") {
|
||||
return nil
|
||||
}
|
||||
|
||||
cmd.SilenceUsage = true
|
||||
|
||||
return errEmptyExcludeValue
|
||||
}
|
||||
|
||||
// runE adapts a subcommand implementation, or the version print, to
|
||||
// cobra's RunE. Cobra prints the error and the command's usage text for
|
||||
// every error RunE returns, but a subcommand that ran and failed has no
|
||||
|
||||
@@ -570,20 +570,21 @@ func TestRunNamesDefaultDatabase(t *testing.T) {
|
||||
}{
|
||||
cmdScan: {
|
||||
run: func() error {
|
||||
return runScan(t.Context(), []string{missing}, 1, false, false)
|
||||
return runScan(t.Context(), []string{missing}, 1, false, false,
|
||||
nil)
|
||||
},
|
||||
want: scanWant,
|
||||
},
|
||||
cmdReport: {
|
||||
run: func() error {
|
||||
return runReport(cancelledContext(t), io.Discard)
|
||||
return runReport(cancelledContext(t), nil, io.Discard)
|
||||
},
|
||||
want: "report: database " + defaultDatabasePath + " (default)\n" +
|
||||
reportOpenLine + "\n" + reportOpenLine + "\n",
|
||||
},
|
||||
cmdTrees: {
|
||||
run: func() error {
|
||||
return runTrees(cancelledContext(t), io.Discard)
|
||||
return runTrees(cancelledContext(t), nil, io.Discard)
|
||||
},
|
||||
want: "trees: database " + defaultDatabasePath + " (default)\n" +
|
||||
treesOpenLine + "\n" + treesOpenLine + "\n",
|
||||
@@ -619,8 +620,6 @@ func TestRunUsageErrors(t *testing.T) {
|
||||
}{
|
||||
"no subcommand": {[]string{}, usageMarker},
|
||||
"scan without paths": {[]string{cmdScan}, usageMarker},
|
||||
"report with args": {[]string{cmdReport, "x"}, usageMarker},
|
||||
"trees with args": {[]string{cmdTrees, "x"}, usageMarker},
|
||||
"info with args": {[]string{cmdInfo, "x"}, usageMarker},
|
||||
"dwim with args": {[]string{cmdDwim, "x"}, usageMarker},
|
||||
"unknown flag": {[]string{cmdScan, "--nope", "/"}, usageMarker},
|
||||
@@ -712,6 +711,16 @@ func TestRunHelp(t *testing.T) {
|
||||
args, got)
|
||||
}
|
||||
}
|
||||
|
||||
// The scan help lists --exclude with its argument.
|
||||
var stdout, stderr bytes.Buffer
|
||||
|
||||
run([]string{cmdScan, "-h"}, &stdout, &stderr)
|
||||
|
||||
if !strings.Contains(stderr.String(), excludeFlag+" PATH") {
|
||||
t.Errorf("scan -h stderr = %q, want %s PATH", stderr.String(),
|
||||
excludeFlag)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunScanUsageLine(t *testing.T) {
|
||||
@@ -719,7 +728,8 @@ func TestRunScanUsageLine(t *testing.T) {
|
||||
|
||||
// README §Subcommands shows this usage line for scan, and the help
|
||||
// and the usage error both print it.
|
||||
const want = "\n sfdupes scan [--workers N] [-x] [--no-default-excludes] PATH...\n"
|
||||
const want = "\n sfdupes scan [--workers N] [-x] [--no-default-excludes] " +
|
||||
"[--exclude PATH]... PATH...\n"
|
||||
|
||||
cases := map[string][]string{
|
||||
"help": {cmdScan, "-h"},
|
||||
@@ -1754,9 +1764,13 @@ func TestStdoutWriteErrorPropagates(t *testing.T) {
|
||||
scanFixture(t)
|
||||
|
||||
cases := map[string]func(context.Context, io.Writer) error{
|
||||
cmdReport: runReport,
|
||||
cmdTrees: runTrees,
|
||||
cmdInfo: runInfo,
|
||||
cmdReport: func(ctx context.Context, w io.Writer) error {
|
||||
return runReport(ctx, nil, w)
|
||||
},
|
||||
cmdTrees: func(ctx context.Context, w io.Writer) error {
|
||||
return runTrees(ctx, nil, w)
|
||||
},
|
||||
cmdInfo: runInfo,
|
||||
}
|
||||
|
||||
for name, fn := range cases {
|
||||
|
||||
@@ -17,7 +17,8 @@ import (
|
||||
// ends it at once, as it ends trees.
|
||||
func runDwim(ctx context.Context, root string, stdout io.Writer) error {
|
||||
scanCtx, stop := interruptContext(ctx)
|
||||
err := runScan(scanCtx, []string{root}, runtime.NumCPU(), false, false)
|
||||
err := runScan(scanCtx, []string{root}, runtime.NumCPU(), false, false,
|
||||
nil)
|
||||
|
||||
stop()
|
||||
|
||||
@@ -25,7 +26,7 @@ func runDwim(ctx context.Context, root string, stdout io.Writer) error {
|
||||
return err
|
||||
}
|
||||
|
||||
err = runTrees(ctx, stdout)
|
||||
err = runTrees(ctx, nil, stdout)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
+103
-11
@@ -1,8 +1,9 @@
|
||||
package sfdupes
|
||||
|
||||
// This file holds two rules for the walk (README "Rules for the walk"):
|
||||
// This file holds three rules for the walk (README "Rules for the
|
||||
// walk"): the paths given with --exclude, which the scan never enters;
|
||||
// the default excludes, the paths a scan's walk does not enter below an
|
||||
// operand unless scan is given --no-default-excludes, and the
|
||||
// operand unless scan is given --no-default-excludes; and the
|
||||
// filesystems that are not persistent, on which the scan never records
|
||||
// or reads anything.
|
||||
|
||||
@@ -12,6 +13,7 @@ import (
|
||||
"fmt"
|
||||
"io"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
@@ -43,17 +45,25 @@ const typesPerHelpLine = 6
|
||||
// readMountInfo reads.
|
||||
var errMountInfoLine = errors.New("unexpected line")
|
||||
|
||||
// errExcludedOperand reports an operand at or below a path given with
|
||||
// --exclude.
|
||||
var errExcludedOperand = errors.New("operand excluded by --exclude")
|
||||
|
||||
// walkRules holds the rules for the walk that a scan sets up as it
|
||||
// starts. excludes are the default excludes, or none with
|
||||
// --no-default-excludes. nonPersistent maps the device ID of every
|
||||
// mounted filesystem that is not persistent to its type; the scan
|
||||
// records and reads nothing on one of those, whatever the flags.
|
||||
// databaseFiles are the scan's own database files, which the walk
|
||||
// passes over (see databaseFiles in db.go).
|
||||
// starts. excludePaths are the paths given with --exclude, each with
|
||||
// the device ID and inode number of the file it names (see
|
||||
// excludePathInodes), which the walk neither enters nor records,
|
||||
// whatever path leads to them. defaultExcludes are the default
|
||||
// excludes, or none with --no-default-excludes. nonPersistent maps the
|
||||
// device ID of every mounted filesystem that is not persistent to its
|
||||
// type; the scan records and reads nothing on one of those, whatever
|
||||
// the flags. databaseFiles are the scan's own database files, which the
|
||||
// walk passes over (see databaseFiles in db.go).
|
||||
type walkRules struct {
|
||||
excludes []string
|
||||
nonPersistent map[uint64]string
|
||||
databaseFiles []fileRec
|
||||
excludePaths []fileRec
|
||||
defaultExcludes []string
|
||||
nonPersistent map[uint64]string
|
||||
databaseFiles []fileRec
|
||||
}
|
||||
|
||||
// defaultExcludes returns the default excludes of the system goos
|
||||
@@ -97,6 +107,88 @@ func isDefaultExclude(path string, excludes []string) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
// excludePathInodes returns each of paths, the --exclude values, as its
|
||||
// real path (see realPaths) with the device ID and inode number of the
|
||||
// file there. The walk compares what it reaches with those, as it does
|
||||
// with the database files, so it also leaves out an --exclude path
|
||||
// spelled another way, such as in another letter case on macOS.
|
||||
func excludePathInodes(paths []string) ([]fileRec, error) {
|
||||
resolved, err := realPaths(paths)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
files := make([]fileRec, 0, len(resolved))
|
||||
|
||||
for _, path := range resolved {
|
||||
fi, err := os.Lstat(path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
dev, ino := inodeOfInfo(fi)
|
||||
files = append(files, fileRec{path: path, dev: dev, ino: ino})
|
||||
}
|
||||
|
||||
return files, nil
|
||||
}
|
||||
|
||||
// matchingExcludePath returns the path of the one of excludePaths with
|
||||
// the device ID and inode number of fi, an lstat result, or "" when
|
||||
// there is none.
|
||||
func matchingExcludePath(fi fs.FileInfo, excludePaths []fileRec) string {
|
||||
dev, ino := inodeOfInfo(fi)
|
||||
f := fileRec{dev: dev, ino: ino}
|
||||
|
||||
for _, exclude := range excludePaths {
|
||||
if sameInode(exclude, f) {
|
||||
return exclude.path
|
||||
}
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// checkOperandsNotExcluded returns an error when one of roots, the
|
||||
// operands, or a directory above it is one of excludePaths, the
|
||||
// --exclude paths, by device ID and inode number. The error names the
|
||||
// operand and the --exclude path. The roots are absolute, so the
|
||||
// directories above each one end at /. A path here that lstat cannot
|
||||
// read is an error too.
|
||||
func checkOperandsNotExcluded(roots []string, excludePaths []fileRec) error {
|
||||
for _, root := range roots {
|
||||
for path := root; ; path = filepath.Dir(path) {
|
||||
fi, err := os.Lstat(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("scan %s: %w", root, err)
|
||||
}
|
||||
|
||||
exclude := matchingExcludePath(fi, excludePaths)
|
||||
if exclude != "" {
|
||||
return fmt.Errorf("scan %s: %w %s", root, errExcludedOperand,
|
||||
exclude)
|
||||
}
|
||||
|
||||
if path == "/" {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// excludePathLine returns the line the scan prints for path when fi,
|
||||
// its lstat, makes it one of rules.excludePaths, and "" when it does
|
||||
// not.
|
||||
func (rules walkRules) excludePathLine(path string, fi fs.FileInfo) string {
|
||||
if matchingExcludePath(fi, rules.excludePaths) == "" {
|
||||
return ""
|
||||
}
|
||||
|
||||
return fmt.Sprintf("scan: skipped %s (--exclude)", path)
|
||||
}
|
||||
|
||||
// nonPersistentFilesystemTypes returns the filesystem types that are
|
||||
// not persistent: filesystems that the kernel makes up or that are kept
|
||||
// in memory. devfs is the macOS filesystem of /dev; the others are
|
||||
|
||||
@@ -14,6 +14,9 @@ import (
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
// excludeFlag is the scan flag that names a path the walk never enters.
|
||||
const excludeFlag = "--exclude"
|
||||
|
||||
func TestDefaultExcludes(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
@@ -188,7 +191,7 @@ func TestScanDoesNotEnterDefaultExclude(t *testing.T) {
|
||||
unseen := writeFile(t, excluded, "new", pattern(2, 10))
|
||||
|
||||
st, err := syncScan(t.Context(), db, []string{dir}, 1, false,
|
||||
walkRules{excludes: []string{excluded}})
|
||||
walkRules{defaultExcludes: []string{excluded}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -234,7 +237,7 @@ func TestScanWalksOperandInDefaultExclude(t *testing.T) {
|
||||
db := openTestDB(t)
|
||||
|
||||
st, err := syncScan(t.Context(), db, roots, 1, false,
|
||||
walkRules{excludes: []string{excluded}})
|
||||
walkRules{defaultExcludes: []string{excluded}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -262,7 +265,7 @@ func TestScanNamesNoDefaultExcludeThatIsAnOperand(t *testing.T) {
|
||||
f := writeFile(t, excluded, "f", pattern(1, 10))
|
||||
|
||||
st, err := syncScan(t.Context(), db, []string{dir, excluded}, 1, false,
|
||||
walkRules{excludes: []string{excluded}})
|
||||
walkRules{defaultExcludes: []string{excluded}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -356,6 +359,217 @@ func TestRunScanNoDefaultExcludes(t *testing.T) {
|
||||
assertRecorded(t, path, f, true)
|
||||
}
|
||||
|
||||
// TestRunScanExcludeNested scans a tree through the command with an
|
||||
// --exclude path two levels below the operand. The walk records nothing
|
||||
// at or below it and says so. The record an earlier scan left there is
|
||||
// kept although its file is gone.
|
||||
func TestRunScanExcludeNested(t *testing.T) {
|
||||
path := testDBPath(t)
|
||||
t.Setenv(databaseEnv, path)
|
||||
|
||||
dir := realTempDir(t)
|
||||
excluded := filepath.Join(dir, "a", "b")
|
||||
kept := writeFile(t, dir, "a/f", pattern(1, 10))
|
||||
gone := writeFile(t, excluded, "gone", pattern(2, 10))
|
||||
|
||||
scanOK(t, dir)
|
||||
|
||||
err := os.Remove(gone)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
unseen := writeFile(t, excluded, "c/new", pattern(3, 10))
|
||||
|
||||
stderr := scanOK(t, excludeFlag, excluded, dir)
|
||||
|
||||
line := "scan: skipped " + excluded + " (--exclude)\n"
|
||||
if !strings.Contains(stderr, line) {
|
||||
t.Errorf("stderr = %q, want %q", stderr, line)
|
||||
}
|
||||
|
||||
assertRecorded(t, path, kept, true)
|
||||
assertRecorded(t, path, gone, true)
|
||||
assertRecorded(t, path, unseen, false)
|
||||
}
|
||||
|
||||
// TestRunScanExcludeRepeated gives --exclude twice, once for a
|
||||
// directory and once for a file, the file through a symlink to it. The
|
||||
// walk records neither, and records the file beside them.
|
||||
func TestRunScanExcludeRepeated(t *testing.T) {
|
||||
path := testDBPath(t)
|
||||
t.Setenv(databaseEnv, path)
|
||||
|
||||
dir := realTempDir(t)
|
||||
inDir := writeFile(t, dir, "skip/f", pattern(1, 10))
|
||||
file := writeFile(t, dir, "skip-file", pattern(2, 10))
|
||||
kept := writeFile(t, dir, "keep", pattern(3, 10))
|
||||
|
||||
link := filepath.Join(t.TempDir(), "link")
|
||||
symlink(t, file, link)
|
||||
|
||||
scanOK(t, excludeFlag, filepath.Dir(inDir), excludeFlag, link, dir)
|
||||
|
||||
assertRecorded(t, path, inDir, false)
|
||||
assertRecorded(t, path, file, false)
|
||||
assertRecorded(t, path, kept, true)
|
||||
}
|
||||
|
||||
// TestRunScanExcludeReachedByAnotherPath gives --exclude a directory
|
||||
// through a symlink and a file through "..", so the walk reaches
|
||||
// neither by the path given. The walk also reaches the file through a
|
||||
// hard link. It records none of these, prints a line naming each, and
|
||||
// records the file beside them.
|
||||
func TestRunScanExcludeReachedByAnotherPath(t *testing.T) {
|
||||
path := testDBPath(t)
|
||||
t.Setenv(databaseEnv, path)
|
||||
|
||||
dir := realTempDir(t)
|
||||
inDir := writeFile(t, dir, "a/cache/f", pattern(1, 10))
|
||||
file := writeFile(t, dir, "a/big", pattern(2, 10))
|
||||
kept := writeFile(t, dir, "keep", pattern(3, 10))
|
||||
|
||||
hardLink := filepath.Join(dir, "big-link")
|
||||
|
||||
err := os.Link(file, hardLink)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
link := filepath.Join(t.TempDir(), "link")
|
||||
symlink(t, filepath.Join(dir, "a"), link)
|
||||
|
||||
// Joined as text, since filepath.Join would drop the "..".
|
||||
dotDot := dir + "/a/cache/../big"
|
||||
|
||||
stderr := scanOK(t, excludeFlag, filepath.Join(link, "cache"),
|
||||
excludeFlag, dotDot, dir)
|
||||
|
||||
for _, skipped := range []string{filepath.Dir(inDir), file, hardLink} {
|
||||
line := "scan: skipped " + skipped + " (--exclude)\n"
|
||||
if !strings.Contains(stderr, line) {
|
||||
t.Errorf("stderr = %q, want %q", stderr, line)
|
||||
}
|
||||
}
|
||||
|
||||
assertRecorded(t, path, inDir, false)
|
||||
assertRecorded(t, path, file, false)
|
||||
assertRecorded(t, path, hardLink, false)
|
||||
assertRecorded(t, path, kept, true)
|
||||
}
|
||||
|
||||
// TestRunScanExcludedOperand checks that an operand at or below an
|
||||
// --exclude path is a fatal error that names both, and so is an
|
||||
// --exclude path that does not exist. An operand that is a hard link to
|
||||
// an --exclude file is at it. Neither scan writes a database.
|
||||
func TestRunScanExcludedOperand(t *testing.T) {
|
||||
dir := realTempDir(t)
|
||||
sub := filepath.Join(dir, "sub")
|
||||
f := writeFile(t, sub, "f", pattern(1, 10))
|
||||
|
||||
hardLink := filepath.Join(dir, "f-link")
|
||||
|
||||
err := os.Link(f, hardLink)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
cases := map[string]struct {
|
||||
args []string
|
||||
want string
|
||||
}{
|
||||
"at it": {
|
||||
[]string{excludeFlag, sub, sub},
|
||||
"scan " + sub + ": operand excluded by --exclude " + sub + "\n",
|
||||
},
|
||||
"below it": {
|
||||
[]string{excludeFlag, dir, sub},
|
||||
"scan " + sub + ": operand excluded by --exclude " + dir + "\n",
|
||||
},
|
||||
"after an operand it does not exclude": {
|
||||
[]string{dir, excludeFlag, sub, sub},
|
||||
"scan " + sub + ": operand excluded by --exclude " + sub + "\n",
|
||||
},
|
||||
"a hard link to it": {
|
||||
[]string{excludeFlag, f, hardLink},
|
||||
"scan " + hardLink + ": operand excluded by --exclude " + f + "\n",
|
||||
},
|
||||
"exclude missing": {
|
||||
[]string{excludeFlag, filepath.Join(dir, "nope"), dir},
|
||||
"--exclude: resolve " + filepath.Join(dir, "nope") + ": ",
|
||||
},
|
||||
}
|
||||
|
||||
for name, tc := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
path := testDBPath(t)
|
||||
t.Setenv(databaseEnv, path)
|
||||
|
||||
stdout := captureStdout(t)
|
||||
stderr := captureStderr(t)
|
||||
|
||||
code := run(append([]string{cmdScan}, tc.args...), os.Stdout,
|
||||
os.Stderr)
|
||||
if code != exitFatal {
|
||||
t.Errorf("run(scan %q) = %d, want %d", tc.args, code,
|
||||
exitFatal)
|
||||
}
|
||||
|
||||
assertFatalOutput(t, stderr(), stdout())
|
||||
|
||||
if !strings.Contains(stderr(), "sfdupes: "+tc.want) {
|
||||
t.Errorf("stderr = %q, want %q", stderr(), tc.want)
|
||||
}
|
||||
|
||||
_, err := os.Lstat(path)
|
||||
if !errors.Is(err, os.ErrNotExist) {
|
||||
t.Errorf("lstat %s: %v, want no database", path, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunScanRejectsEmptyExclude checks that an empty --exclude value,
|
||||
// given as its own argument, after "=" or after another --exclude, is
|
||||
// a usage error reported in one line before anything is scanned
|
||||
// (README "Settings").
|
||||
func TestRunScanRejectsEmptyExclude(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
cases := map[string][]string{
|
||||
"separate": {excludeFlag, "", dir},
|
||||
"joined by =": {excludeFlag + "=", dir},
|
||||
"after a path": {excludeFlag, t.TempDir(), excludeFlag, "", dir},
|
||||
}
|
||||
|
||||
for name, args := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
path := testDBPath(t)
|
||||
t.Setenv(databaseEnv, path)
|
||||
|
||||
var stdout, stderr bytes.Buffer
|
||||
|
||||
code := run(append([]string{cmdScan}, args...), &stdout,
|
||||
&stderr)
|
||||
if code != exitUsage {
|
||||
t.Errorf("run(scan %q) = %d, want %d", args, code,
|
||||
exitUsage)
|
||||
}
|
||||
|
||||
want := "Error: --exclude must not be empty\n"
|
||||
if stdout.String() != "" || stderr.String() != want {
|
||||
t.Errorf("stdout, stderr = %q, %q, want \"\", %q",
|
||||
stdout.String(), stderr.String(), want)
|
||||
}
|
||||
|
||||
_, err := os.Lstat(path)
|
||||
if !errors.Is(err, os.ErrNotExist) {
|
||||
t.Errorf("lstat %s: %v, want no database", path, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunScanSkipsNonPersistentOperand scans, through the command, a
|
||||
// directory on a filesystem that is not persistent, with and without
|
||||
// --no-default-excludes: either way it is skipped, with a line saying
|
||||
|
||||
+69
-14
@@ -9,6 +9,7 @@ import (
|
||||
"io"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"syscall"
|
||||
@@ -44,10 +45,12 @@ func reportPhase(name string) string {
|
||||
}
|
||||
|
||||
// runReport implements the report subcommand: it prints the file-level
|
||||
// duplicates report as TSV on stdout. Of the scanned filesystem it
|
||||
// only checks, with pathExists, that each path in a duplicate group is
|
||||
// still there. It names the database on stderr before it opens it. Any
|
||||
// database problem, including a missing database, is fatal.
|
||||
// duplicates report as TSV on stdout, from the records at or below the
|
||||
// operands in args, or from every record when args is empty. Of the
|
||||
// scanned filesystem it only checks, with pathExists, that each path in
|
||||
// a duplicate group is still there; it never looks up an operand. It
|
||||
// names the database on stderr before it opens it. Any database
|
||||
// problem, including a missing database, is fatal.
|
||||
//
|
||||
// The work runs in two phases, each under a progress display of its
|
||||
// own on stderr: open (open the database) and read (read the number of
|
||||
@@ -55,7 +58,12 @@ func reportPhase(name string) string {
|
||||
// order, writing each size's duplicate groups to stdout once that size
|
||||
// is read; see readReport). Each display ends before the next phase
|
||||
// starts, and before an error is returned to be printed.
|
||||
func runReport(ctx context.Context, stdout io.Writer) error {
|
||||
func runReport(ctx context.Context, args []string, stdout io.Writer) error {
|
||||
operands, err := cleanOperands(args)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
dbPath, source, err := databasePath()
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -87,7 +95,8 @@ func runReport(ctx context.Context, stdout io.Writer) error {
|
||||
label: reportPhase("read"), unit: "records", total: -1,
|
||||
waitingFor: countingRecords, stalledOn: "db/disk/out",
|
||||
})
|
||||
report, err := readReport(ctx, db, dbPath, stdout, pathExists, prog)
|
||||
report, err := readReport(ctx, db, dbPath, operands, stdout, pathExists,
|
||||
prog)
|
||||
|
||||
prog.finish()
|
||||
|
||||
@@ -108,12 +117,14 @@ func runReport(ctx context.Context, stdout io.Writer) error {
|
||||
// dbPath, as its total, then reads every record in signature order,
|
||||
// counting each on prog, and writes the report to stdout: the header
|
||||
// line, then the rows of each size's duplicate groups once that size is
|
||||
// read. A path for which exists returns false is left out of its group.
|
||||
// stdout may be the terminal prog is drawn on, so the lines go through
|
||||
// prog's writer. It returns what it wrote, with the totals for the
|
||||
// summary line.
|
||||
// read. Only the records that underOperand finds under operands join a
|
||||
// group, and a path for which exists returns false is left out of its
|
||||
// group. stdout may be the terminal prog is drawn on, so the lines go
|
||||
// through prog's writer. It returns what it wrote, with the totals for
|
||||
// the summary line.
|
||||
func readReport(ctx context.Context, db *sql.DB, dbPath string,
|
||||
stdout io.Writer, exists func(path string) bool, prog *progress,
|
||||
operands []string, stdout io.Writer, exists func(path string) bool,
|
||||
prog *progress,
|
||||
) (*reportWriter, error) {
|
||||
out := prog.writer(stdout)
|
||||
report := &reportWriter{out: out, exists: exists}
|
||||
@@ -128,6 +139,12 @@ func readReport(ctx context.Context, db *sql.DB, dbPath string,
|
||||
err = loadSignatureRows(ctx, db, prog.setTotal, func(r scanRec) error {
|
||||
prog.increment()
|
||||
|
||||
report.records++
|
||||
|
||||
if !underOperand(r.path, operands) {
|
||||
return nil
|
||||
}
|
||||
|
||||
writeErr = report.add(r)
|
||||
|
||||
return writeErr
|
||||
@@ -159,7 +176,7 @@ func readReport(ctx context.Context, db *sql.DB, dbPath string,
|
||||
// records of one size, so it holds only the duplicate groups of the
|
||||
// size being read, and writes them, ordered by first path, once a
|
||||
// record of a smaller size comes. It counts what the summary line
|
||||
// reports.
|
||||
// reports; readReport counts the records read.
|
||||
type reportWriter struct {
|
||||
out io.Writer
|
||||
|
||||
@@ -179,8 +196,6 @@ type reportWriter struct {
|
||||
// its paths; any other ends them, and one of a smaller size first
|
||||
// writes the groups of the size before.
|
||||
func (w *reportWriter) add(r scanRec) error {
|
||||
w.records++
|
||||
|
||||
if r.size == w.sig.size && r.head == w.sig.head &&
|
||||
r.tail == w.sig.tail && r.content == w.sig.content {
|
||||
w.paths = append(w.paths, r.path)
|
||||
@@ -273,6 +288,46 @@ func pathExists(path string) bool {
|
||||
return !errors.Is(err, fs.ErrNotExist) && !errors.Is(err, syscall.ENOTDIR)
|
||||
}
|
||||
|
||||
// cleanOperands returns the operands of report or trees, each made
|
||||
// absolute by absolutePath and then cleaned. The records hold real
|
||||
// paths, with no "." or ".." element and no repeated or trailing
|
||||
// slash, so an operand is cleaned to match them. No operand is looked
|
||||
// up on the filesystem.
|
||||
func cleanOperands(args []string) ([]string, error) {
|
||||
operands := make([]string, 0, len(args))
|
||||
|
||||
for _, a := range args {
|
||||
abs, err := absolutePath(a)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("resolve path %s: %w", escapePath(a), err)
|
||||
}
|
||||
|
||||
operands = append(operands, filepath.Clean(abs))
|
||||
}
|
||||
|
||||
return operands, nil
|
||||
}
|
||||
|
||||
// underOperand reports whether path is one of operands or lies below
|
||||
// one of them. Each operand is clean and absolute, as cleanOperands
|
||||
// returns it. With no operands, a report covers the whole database, so
|
||||
// underOperand is true for every path.
|
||||
func underOperand(path string, operands []string) bool {
|
||||
if len(operands) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
for _, o := range operands {
|
||||
// Only the root directory's clean path ends in "/".
|
||||
dir := strings.TrimSuffix(o, "/") + "/"
|
||||
if path == o || strings.HasPrefix(path, dir) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// escapePath returns a path as it is written in a report column (README
|
||||
// "Report output format"): a backslash, tab, newline or carriage return
|
||||
// becomes \\, \t, \n or \r, and every other byte is kept as it is.
|
||||
|
||||
@@ -102,7 +102,8 @@ func dupeGroups(t *testing.T, db *sql.DB) []dupeGroup {
|
||||
|
||||
var out bytes.Buffer
|
||||
|
||||
_, err := readReport(t.Context(), db, "", &out, everyPathExists, nil)
|
||||
_, err := readReport(t.Context(), db, "", nil, &out, everyPathExists,
|
||||
nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -148,6 +149,103 @@ func dupeGroupsOf(t *testing.T, recs []scanRec) []dupeGroup {
|
||||
return dupeGroups(t, db)
|
||||
}
|
||||
|
||||
// TestRunReportOperands runs report with operands on three copies of
|
||||
// one file, two of them under srv/photos, and a fourth copy in
|
||||
// srv/photos2, all in a new directory. Only the records at or below the
|
||||
// operands form the groups and the totals, however each operand is
|
||||
// written.
|
||||
//
|
||||
//nolint:paralleltest // captureStderr replaces the process-wide os.Stderr
|
||||
func TestRunReportOperands(t *testing.T) {
|
||||
h := testHash("h")
|
||||
|
||||
recs := make([]scanRec, 0, 4)
|
||||
for _, p := range []string{
|
||||
"/a/copy", "/srv/photos/x", "/srv/photos/y", "/srv/photos2/z",
|
||||
} {
|
||||
recs = append(recs,
|
||||
scanRec{size: 7, head: h, tail: h, content: h, path: p})
|
||||
}
|
||||
|
||||
dir, recs := recsOnDisk(t, recs)
|
||||
a, x, y, z := recs[0].path, recs[1].path, recs[2].path, recs[3].path
|
||||
|
||||
t.Setenv(databaseEnv, seedDatabase(t, recs))
|
||||
|
||||
header := "first\tdupe\tsize\n"
|
||||
row := func(first, dupe string) string {
|
||||
return first + "\t" + dupe + "\t7\n"
|
||||
}
|
||||
photos := header + row(x, y)
|
||||
|
||||
cases := map[string]struct {
|
||||
operands []string
|
||||
want string
|
||||
summary string
|
||||
}{
|
||||
"directory": {[]string{dir + "/srv/photos"}, photos,
|
||||
"1 duplicate groups, 1 dupe files, 7 B reclaimable"},
|
||||
"trailing slash": {[]string{dir + "/srv/photos/"}, photos, ""},
|
||||
"dot and dot-dot": {[]string{dir + "/srv/./a/../photos"}, photos, ""},
|
||||
"files": {[]string{a, z}, header + row(a, z), ""},
|
||||
"overlapping": {[]string{dir + "/srv", dir + "/srv/photos"},
|
||||
header + row(x, y) + row(x, z), ""},
|
||||
"root": {[]string{"/"},
|
||||
header + row(a, x) + row(a, y) + row(a, z), ""},
|
||||
"no record": {[]string{dir + "/srv/photo"}, header,
|
||||
"0 duplicate groups, 0 dupe files, 0 B reclaimable"},
|
||||
}
|
||||
|
||||
for name, tc := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
var stdout bytes.Buffer
|
||||
|
||||
stderr := captureStderr(t)
|
||||
|
||||
code := run(append([]string{cmdReport}, tc.operands...),
|
||||
&stdout, os.Stderr)
|
||||
if code != exitOK {
|
||||
t.Fatalf("run(report %q) = %d, want %d; stderr: %s",
|
||||
tc.operands, code, exitOK, stderr())
|
||||
}
|
||||
|
||||
if got := stdout.String(); got != tc.want {
|
||||
t.Errorf("stdout = %q, want %q", got, tc.want)
|
||||
}
|
||||
|
||||
// The records read are all four, whatever the operands.
|
||||
summary := "report: 4 records read, " + tc.summary + "\n"
|
||||
if got := stderr(); tc.summary != "" &&
|
||||
!strings.HasSuffix(got, summary) {
|
||||
t.Errorf("stderr = %q, want it to end %q", got, summary)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
//nolint:paralleltest // t.Chdir changes the process-wide working directory
|
||||
func TestCleanOperandsMakesRelativePathsAbsolute(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
t.Chdir(dir)
|
||||
|
||||
wd, err := absolutePath(".")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
got, err := cleanOperands([]string{"photos/", "a/../b", "/c//d"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
want := []string{
|
||||
filepath.Join(wd, "photos"), filepath.Join(wd, "b"), "/c/d",
|
||||
}
|
||||
if !slices.Equal(got, want) {
|
||||
t.Errorf("cleanOperands = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunReportEscapesPaths(t *testing.T) {
|
||||
dir, recs := recsOnDisk(t, awkwardPairRecs())
|
||||
t.Setenv(databaseEnv, seedDatabase(t, recs))
|
||||
@@ -195,7 +293,7 @@ func TestReportStdoutFailsWhileReading(t *testing.T) {
|
||||
// Counts the records read, and draws nothing.
|
||||
prog := &progress{now: time.Now}
|
||||
|
||||
_, err = readReport(t.Context(), db, "", failingWriter{},
|
||||
_, err = readReport(t.Context(), db, "", nil, failingWriter{},
|
||||
everyPathExists, prog)
|
||||
if !errors.Is(err, errWriteFailed) ||
|
||||
!strings.HasPrefix(err.Error(), "write stdout: ") {
|
||||
@@ -292,7 +390,8 @@ func TestReadReportOnTerminal(t *testing.T) {
|
||||
waitingFor: countingRecords,
|
||||
}, terminalWidth, time.Hour, time.Now)
|
||||
|
||||
_, err = readReport(t.Context(), db, "", os.Stderr, everyPathExists, p)
|
||||
_, err = readReport(t.Context(), db, "", nil, os.Stderr,
|
||||
everyPathExists, p)
|
||||
|
||||
p.finish()
|
||||
|
||||
@@ -514,7 +613,7 @@ func TestReadReportChecksOnlyPossibleDuplicates(t *testing.T) {
|
||||
return true
|
||||
}
|
||||
|
||||
_, err = readReport(t.Context(), db, "", io.Discard, exists, nil)
|
||||
_, err = readReport(t.Context(), db, "", nil, io.Discard, exists, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -548,7 +647,8 @@ func TestReadReportDropsGroupLeftWithOnePath(t *testing.T) {
|
||||
|
||||
exists := func(path string) bool { return path != "/a/gone" }
|
||||
|
||||
report, err := readReport(t.Context(), db, "", io.Discard, exists, nil)
|
||||
report, err := readReport(t.Context(), db, "", nil, io.Discard, exists,
|
||||
nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -581,7 +681,7 @@ func TestReadReportKeepsGroupLeftWithTwoPaths(t *testing.T) {
|
||||
|
||||
var out bytes.Buffer
|
||||
|
||||
report, err := readReport(t.Context(), db, "", &out, exists, nil)
|
||||
report, err := readReport(t.Context(), db, "", nil, &out, exists, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
+77
-47
@@ -102,40 +102,44 @@ func scanPhase(name string) string {
|
||||
// scan command rejects anything less. Before the lock is taken, the
|
||||
// scan lists the filesystems that are not persistent, on which the walk
|
||||
// records nothing; unless noDefaultExcludes is set, the walk does not
|
||||
// enter the default excludes either. Once the database is open, the
|
||||
// scan notes its files, which the walk passes over.
|
||||
// enter the default excludes either. The walk neither enters nor
|
||||
// records the paths in excludePaths, the --exclude values; an operand
|
||||
// at or below one is a fatal error. Once the database is open, the scan
|
||||
// notes its files, which the walk passes over.
|
||||
func runScan(ctx context.Context, roots []string, workers int,
|
||||
oneFS, noDefaultExcludes bool,
|
||||
oneFS, noDefaultExcludes bool, excludePaths []string,
|
||||
) error {
|
||||
dbPath, source, err := databasePath()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// A database file missing now is created by lockScanDatabase below.
|
||||
what := "database"
|
||||
printDatabasePath(dbPath, source)
|
||||
|
||||
_, err = os.Stat(dbPath)
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
what = "new database"
|
||||
}
|
||||
|
||||
fmt.Fprintf(os.Stderr, "scan: %s %s (%s)\n", what, escapePath(dbPath),
|
||||
source)
|
||||
|
||||
roots, err = resolveRoots(roots)
|
||||
roots, err = realPaths(roots)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
nonPersistent, err := nonPersistentFilesystems()
|
||||
var rules walkRules
|
||||
|
||||
rules.excludePaths, err = excludePathInodes(excludePaths)
|
||||
if err != nil {
|
||||
return fmt.Errorf("--exclude: %w", err)
|
||||
}
|
||||
|
||||
err = checkOperandsNotExcluded(roots, rules.excludePaths)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
rules.nonPersistent, err = nonPersistentFilesystems()
|
||||
if err != nil {
|
||||
return fmt.Errorf("list the mounted filesystems: %w", err)
|
||||
}
|
||||
|
||||
rules := walkRules{nonPersistent: nonPersistent}
|
||||
if !noDefaultExcludes {
|
||||
rules.excludes = defaultExcludes(runtime.GOOS)
|
||||
rules.defaultExcludes = defaultExcludes(runtime.GOOS)
|
||||
}
|
||||
|
||||
lock, err := lockScanDatabase(dbPath)
|
||||
@@ -181,6 +185,21 @@ func runScan(ctx context.Context, roots []string, workers int,
|
||||
return nil
|
||||
}
|
||||
|
||||
// printDatabasePath prints on stderr the line that names the database
|
||||
// at dbPath, with source, saying whether it is new. A database file
|
||||
// missing now is new: lockScanDatabase creates it.
|
||||
func printDatabasePath(dbPath, source string) {
|
||||
what := "database"
|
||||
|
||||
_, err := os.Stat(dbPath)
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
what = "new database"
|
||||
}
|
||||
|
||||
fmt.Fprintf(os.Stderr, "scan: %s %s (%s)\n", what, escapePath(dbPath),
|
||||
source)
|
||||
}
|
||||
|
||||
// interruptContext returns a copy of ctx that the first SIGINT or
|
||||
// SIGTERM cancels; the scan command runs the scan under it. stop
|
||||
// releases the signals.
|
||||
@@ -209,24 +228,25 @@ func interrupted(walked int) error {
|
||||
return errInterrupted
|
||||
}
|
||||
|
||||
// resolveRoots converts each PATH operand to its real path: absolute,
|
||||
// with every symlink in it followed. Database records are keyed by
|
||||
// that path, so scan results depend neither on the working directory
|
||||
// nor on the symlinks an operand was given through. An operand that
|
||||
// cannot be resolved, because it or a symlink's target does not exist
|
||||
// or cannot be read, is a fatal error before any scanning.
|
||||
func resolveRoots(roots []string) ([]string, error) {
|
||||
resolved := make([]string, 0, len(roots))
|
||||
// realPaths returns the real path of each of paths, the PATH operands
|
||||
// or the --exclude values: absolute, with every symlink in it followed.
|
||||
// Database records are keyed by that path, so scan results depend
|
||||
// neither on the working directory nor on the symlinks an operand was
|
||||
// given through. A path that cannot be resolved, because it or a
|
||||
// symlink's target does not exist or cannot be read, is a fatal error
|
||||
// before any scanning.
|
||||
func realPaths(paths []string) ([]string, error) {
|
||||
resolved := make([]string, 0, len(paths))
|
||||
|
||||
for _, root := range roots {
|
||||
a, err := absolutePath(root)
|
||||
for _, path := range paths {
|
||||
a, err := absolutePath(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("resolve %s: %w", root, err)
|
||||
return nil, fmt.Errorf("resolve %s: %w", path, err)
|
||||
}
|
||||
|
||||
r, err := filepath.EvalSymlinks(a)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("resolve %s: %w", root, err)
|
||||
return nil, fmt.Errorf("resolve %s: %w", path, err)
|
||||
}
|
||||
|
||||
resolved = append(resolved, r)
|
||||
@@ -295,7 +315,7 @@ func walkReaches(above, r string, oneFS bool, rules walkRules,
|
||||
}
|
||||
|
||||
for ; dir != above; dir = filepath.Dir(dir) {
|
||||
if isDefaultExclude(dir, rules.excludes) {
|
||||
if isDefaultExclude(dir, rules.defaultExcludes) {
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -418,7 +438,7 @@ func (s *scanState) runPhases(ctx context.Context, roots []string,
|
||||
|
||||
// walkableRoots returns the operands the walk can start from: regular
|
||||
// files, and directories not named .zfs, none of them inside a
|
||||
// directory named .zfs. The operands are real paths from resolveRoots,
|
||||
// directory named .zfs. The operands are real paths from realPaths,
|
||||
// so these checks apply to what a symlink operand points at. Every
|
||||
// other operand is warned about, counted as skipped, and dropped. A
|
||||
// dropped operand is no longer a root, so the records stored beneath it
|
||||
@@ -493,10 +513,11 @@ func (s *scanState) loadIndex(ctx context.Context, roots []string) error {
|
||||
// as verified. When its disk_size differs from the record's, it is
|
||||
// queued for the update phase, which writes the new disk_size. A record
|
||||
// at or below a path the walk left out, because -x stopped at it, it is
|
||||
// a default exclude, or it is not on a persistent filesystem, counts as
|
||||
// outside the roots: it is not deleted. That does not hold below a root
|
||||
// at or inside that path, since that root's own walk verifies the
|
||||
// records below it; nor is a line printed for such a root.
|
||||
// an --exclude path or a default exclude, or it is not on a persistent
|
||||
// filesystem, counts as outside the roots: it is not deleted. That does
|
||||
// not hold below a root at or inside that path, since that root's own
|
||||
// walk verifies the records below it; nor is a line printed for such a
|
||||
// root.
|
||||
func (s *scanState) walkPhase(events <-chan walkEvent, roots []string) {
|
||||
// The records the last scan left under the roots estimate how many
|
||||
// files the walk will find. A first scan has none, and no estimate.
|
||||
@@ -834,9 +855,9 @@ type dirJob struct {
|
||||
// file's statted record, a warning when fail is set, or a path the walk
|
||||
// left out: when otherFSDir is set, a directory -x did not enter
|
||||
// because it is on another filesystem than its operand, and when
|
||||
// leftOut is set, a default exclude or a directory or file on a
|
||||
// filesystem that is not persistent, with warn holding the line that
|
||||
// says so.
|
||||
// leftOut is set, an --exclude path, a default exclude or a directory or
|
||||
// file on a filesystem that is not persistent, with warn holding the
|
||||
// line that says so.
|
||||
type walkEvent struct {
|
||||
rec fileRec
|
||||
warn string
|
||||
@@ -887,7 +908,7 @@ func sendEvent(ctx context.Context, events chan<- walkEvent,
|
||||
// operandWarning returns the one-line warning for an operand the walk
|
||||
// does not start from, naming the path and what it is, or "" for one it
|
||||
// does: a regular file, or a directory not named .zfs, that is not
|
||||
// inside a directory named .zfs. resolveRoots has already followed the
|
||||
// inside a directory named .zfs. realPaths has already followed the
|
||||
// operand's symlinks, so a symlink here is an operand replaced by one
|
||||
// after it was resolved, and is not followed.
|
||||
func operandWarning(root string, fi fs.FileInfo) string {
|
||||
@@ -1118,8 +1139,9 @@ func walkOneDir(ctx context.Context, job dirJob, oneFS bool,
|
||||
// no longer exists, and one that has stopped being a regular file is
|
||||
// skipped. A file on a filesystem in rules that is not persistent, as
|
||||
// through a bind mount of one file, is not recorded: it gets an event
|
||||
// naming it instead. One of the scan's own database files in rules gets
|
||||
// no event at all.
|
||||
// naming it instead, and so does a file given with --exclude, reached
|
||||
// by any path, a hard link to it included. One of the scan's own
|
||||
// database files in rules gets no event at all.
|
||||
func emitFile(ctx context.Context, p string, e fs.DirEntry,
|
||||
rules walkRules, events chan<- walkEvent,
|
||||
) {
|
||||
@@ -1143,6 +1165,10 @@ func emitFile(ctx context.Context, p string, e fs.DirEntry,
|
||||
}
|
||||
|
||||
line := rules.nonPersistentLine(p, info)
|
||||
if line == "" {
|
||||
line = rules.excludePathLine(p, info)
|
||||
}
|
||||
|
||||
if line != "" {
|
||||
sendEvent(ctx, events, walkEvent{leftOut: p, warn: line})
|
||||
|
||||
@@ -1167,11 +1193,11 @@ func emitFile(ctx context.Context, p string, e fs.DirEntry,
|
||||
// subdirJob applies the descent rules to directory p: never enter
|
||||
// .zfs (ZFS snapshot pseudo-dirs would list every file once per
|
||||
// snapshot), never enter a directory on a filesystem in rules that is
|
||||
// not persistent, nor a default exclude in rules, and with -x never
|
||||
// enter a directory on a different filesystem than its operand. For the
|
||||
// last three it sends an event that names the directory, so the scan
|
||||
// keeps the records below it, except those below an operand at or
|
||||
// inside it.
|
||||
// not persistent, nor an --exclude path or a default exclude in rules,
|
||||
// and with -x never enter a directory on a different filesystem than
|
||||
// its operand. For all but .zfs it sends an event that names the
|
||||
// directory, so the scan keeps the records below it, except those below
|
||||
// an operand at or inside it.
|
||||
func subdirJob(ctx context.Context, p string, e fs.DirEntry,
|
||||
parent dirJob, oneFS bool, rules walkRules,
|
||||
events chan<- walkEvent,
|
||||
@@ -1196,13 +1222,17 @@ func subdirJob(ctx context.Context, p string, e fs.DirEntry,
|
||||
}
|
||||
|
||||
line := rules.nonPersistentLine(p, info)
|
||||
if line == "" {
|
||||
line = rules.excludePathLine(p, info)
|
||||
}
|
||||
|
||||
if line != "" {
|
||||
sendEvent(ctx, events, walkEvent{leftOut: p, warn: line})
|
||||
|
||||
return dirJob{}, false
|
||||
}
|
||||
|
||||
if isDefaultExclude(p, rules.excludes) {
|
||||
if isDefaultExclude(p, rules.defaultExcludes) {
|
||||
sendEvent(ctx, events, walkEvent{
|
||||
leftOut: p,
|
||||
warn: fmt.Sprintf("scan: skipped %s (default exclude)", p),
|
||||
|
||||
@@ -2289,7 +2289,7 @@ func TestPruneRoots(t *testing.T) {
|
||||
|
||||
// The walk of /p does not enter /p/q when it is a default exclude, so
|
||||
// /p/q is kept, without -x too; /p/q/r lies under it and is dropped.
|
||||
got = pruneRoots(nested, false, walkRules{excludes: []string{pqRoot}},
|
||||
got = pruneRoots(nested, false, walkRules{defaultExcludes: []string{pqRoot}},
|
||||
device)
|
||||
if !slices.Equal(got, want) {
|
||||
t.Fatalf("pruneRoots excluding %s = %q, want %q", pqRoot, got, want)
|
||||
|
||||
+45
-14
@@ -37,12 +37,14 @@ func treesPhase(name string) string {
|
||||
|
||||
// runTrees implements the trees subcommand: it reads every record from
|
||||
// the database in path order, reconstructs the directory hierarchy from
|
||||
// the record paths, computes a Merkle-style digest per directory, and
|
||||
// prints maximal duplicate-tree groups as TSV on stdout. Of the scanned
|
||||
// filesystem it only checks, with pathExists, that the root of each
|
||||
// duplicate tree is still there, never the files below it. It names the
|
||||
// database on stderr before it opens it. Any database problem,
|
||||
// including a missing database, is fatal.
|
||||
// the paths of the records at or below the operands in args (of every
|
||||
// record when args is empty), computes a Merkle-style digest per
|
||||
// directory, and prints maximal duplicate-tree groups as TSV on stdout.
|
||||
// Of the scanned filesystem it only checks, with pathExists, that the
|
||||
// root of each duplicate tree is still there, never the files below it;
|
||||
// it never looks up an operand. It names the database on stderr before
|
||||
// it opens it. Any database problem, including a missing database, is
|
||||
// fatal.
|
||||
//
|
||||
// The work runs in four phases, each under a progress display of its
|
||||
// own on stderr: open (open the database), read (read the number of
|
||||
@@ -50,7 +52,12 @@ func treesPhase(name string) string {
|
||||
// hierarchy), group (group the directories by digest) and write (write
|
||||
// the groups to stdout). Each display ends before the next phase
|
||||
// starts, and before an error is returned to be printed.
|
||||
func runTrees(ctx context.Context, stdout io.Writer) error {
|
||||
func runTrees(ctx context.Context, args []string, stdout io.Writer) error {
|
||||
operands, err := cleanOperands(args)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
dbPath, source, err := databasePath()
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -79,7 +86,7 @@ func runTrees(ctx context.Context, stdout io.Writer) error {
|
||||
label: treesPhase("read"), unit: "records", total: -1,
|
||||
waitingFor: countingRecords, stalledOn: "db",
|
||||
})
|
||||
records, super, allDirs, err := readTree(ctx, db, prog)
|
||||
records, super, allDirs, err := readTree(ctx, db, operands, prog)
|
||||
|
||||
prog.finish()
|
||||
|
||||
@@ -118,10 +125,17 @@ func runTrees(ctx context.Context, stdout io.Writer) error {
|
||||
}
|
||||
|
||||
// readTree gives prog the number of records in db as its total, then
|
||||
// reads every record in path order into the directory hierarchy,
|
||||
// counting each on prog. It returns the number of records read, the
|
||||
// super-root and every directory.
|
||||
func readTree(ctx context.Context, db *sql.DB,
|
||||
// reads every record in path order, counting each on prog. It adds the
|
||||
// records that underOperand finds under operands to the directory
|
||||
// hierarchy. It returns the number of records read, the super-root and
|
||||
// every directory at or below one of operands.
|
||||
//
|
||||
// Any other directory lies above an operand and can hold files that are
|
||||
// not used, so its digest does not describe it. It is left out of the
|
||||
// directories returned. A directory whose parent is left out gets the
|
||||
// super-root as its parent, so suppressed never judges its group by
|
||||
// that parent's digest.
|
||||
func readTree(ctx context.Context, db *sql.DB, operands []string,
|
||||
prog *progress,
|
||||
) (int, *treeNode, []*treeNode, error) {
|
||||
records := 0
|
||||
@@ -131,7 +145,10 @@ func readTree(ctx context.Context, db *sql.DB,
|
||||
records++
|
||||
|
||||
prog.increment()
|
||||
tree.add(r)
|
||||
|
||||
if underOperand(r.path, operands) {
|
||||
tree.add(r)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
return 0, nil, nil, err
|
||||
@@ -139,7 +156,21 @@ func readTree(ctx context.Context, db *sql.DB,
|
||||
|
||||
super, allDirs := tree.finish()
|
||||
|
||||
return records, super, allDirs, nil
|
||||
dirs := allDirs[:0]
|
||||
|
||||
for _, d := range allDirs {
|
||||
if !underOperand(d.path, operands) {
|
||||
continue
|
||||
}
|
||||
|
||||
if !underOperand(d.parent.path, operands) {
|
||||
d.parent = super
|
||||
}
|
||||
|
||||
dirs = append(dirs, d)
|
||||
}
|
||||
|
||||
return records, super, dirs, nil
|
||||
}
|
||||
|
||||
// writeTreeGroups writes dupes to stdout as TSV, a header line and then
|
||||
|
||||
@@ -214,6 +214,57 @@ func TestRunTreesEscapesPaths(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunTreesOperands runs trees with operands on records in a new
|
||||
// directory. x/a and y/a are copies, and so are y/a and srv/b. x and y
|
||||
// also hold files that differ. Given x/a and y/a, trees reads x and y
|
||||
// as holding one copy each of a, yet neither is reported: only the
|
||||
// directories at or below an operand are.
|
||||
func TestRunTreesOperands(t *testing.T) {
|
||||
f, g, k := testHash("f"), testHash("g"), testHash("k")
|
||||
dir, recs := recsOnDisk(t, []scanRec{
|
||||
{size: 10, head: f, tail: f, content: f, path: "/srv/b/f"},
|
||||
{size: 10, head: f, tail: f, content: f, path: "/x/a/f"},
|
||||
{size: 20, head: g, tail: g, content: g, path: "/x/g"},
|
||||
{size: 10, head: f, tail: f, content: f, path: "/y/a/f"},
|
||||
{size: 30, head: k, tail: k, content: k, path: "/y/k"},
|
||||
})
|
||||
b, xa, ya := dir+"/srv/b", dir+"/x/a", dir+"/y/a"
|
||||
|
||||
header := "first\tdupe\tfiles\tsize\tdisk_size\n"
|
||||
row := func(first, dupe string) string {
|
||||
return first + "\t" + dupe + "\t1\t10\t0\n"
|
||||
}
|
||||
|
||||
cases := map[string]struct {
|
||||
operands []string
|
||||
want string
|
||||
}{
|
||||
"none": {nil, header + row(b, xa) + row(b, ya)},
|
||||
"two copies": {[]string{xa, ya}, header + row(xa, ya)},
|
||||
"parents": {[]string{dir + "/x", dir + "/y"}, header + row(xa, ya)},
|
||||
"one copy": {[]string{b}, header},
|
||||
}
|
||||
|
||||
for name, tc := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
t.Setenv(databaseEnv, seedDatabase(t, recs))
|
||||
|
||||
var stdout, stderr bytes.Buffer
|
||||
|
||||
code := run(append([]string{cmdTrees}, tc.operands...),
|
||||
&stdout, &stderr)
|
||||
if code != exitOK {
|
||||
t.Fatalf("run(trees %q) = %d, want %d; stderr: %s",
|
||||
tc.operands, code, exitOK, stderr.String())
|
||||
}
|
||||
|
||||
if got := stdout.String(); got != tc.want {
|
||||
t.Errorf("stdout = %q, want %q", got, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunTreesDiskSize runs trees on two copies of a tree whose files
|
||||
// take different space on disk. The row's disk_size is the sum over the
|
||||
// dupe copy's files, those in its subdirectory included.
|
||||
|
||||
Reference in new issue
Block a user