Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sneak
|
cadce2148d |
No files matched your search
@@ -43,9 +43,7 @@ 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.
|
||||
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.
|
||||
`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.
|
||||
@@ -260,8 +258,8 @@ In order:
|
||||
|
||||
```
|
||||
sfdupes scan [--workers N] [-x] [--no-default-excludes] [--exclude PATH]... PATH...
|
||||
sfdupes report [PATH...] > dupes.tsv
|
||||
sfdupes trees [PATH...] > dupetrees.tsv
|
||||
sfdupes report > dupes.tsv
|
||||
sfdupes trees > dupetrees.tsv
|
||||
sfdupes info
|
||||
sfdupes dwim [--workers N] [-x] [--no-default-excludes] [--exclude PATH]...
|
||||
sfdupes --version
|
||||
@@ -688,12 +686,11 @@ and `scan` leaves it ignored.
|
||||
|
||||
### `report` mode
|
||||
|
||||
`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:
|
||||
`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:
|
||||
|
||||
- A path is gone when `lstat` finds that it, or a directory above it, does not
|
||||
exist.
|
||||
@@ -725,27 +722,6 @@ 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; it adds nothing to the
|
||||
report.
|
||||
|
||||
#### Report output format
|
||||
|
||||
The report is TSV (tab-separated values) on stdout. It holds a header line, then
|
||||
@@ -773,8 +749,7 @@ Grouping and ordering use the stored path. The warnings about skipped paths that
|
||||
|
||||
The summary line on stderr gives:
|
||||
|
||||
- the records read, which are all the records in the database, with or without
|
||||
operands;
|
||||
- the records read;
|
||||
- the duplicate groups;
|
||||
- the dupe files, which is the number of rows;
|
||||
- the reclaimable bytes, the sum of `size` over all rows.
|
||||
@@ -785,12 +760,11 @@ 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 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
|
||||
`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
|
||||
the directory at the top of each copy still exists, as `report` checks a path.
|
||||
|
||||
Definitions:
|
||||
@@ -818,11 +792,6 @@ 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
|
||||
@@ -876,11 +845,11 @@ directory's path is `/`.
|
||||
|
||||
The summary line on stderr gives:
|
||||
|
||||
- the records read, which are all the records in the database, with or without
|
||||
operands;
|
||||
- the records read;
|
||||
- the duplicate-tree groups;
|
||||
- the dupe trees, which is the number of rows;
|
||||
- the reclaimable bytes, the sum of `size` over all rows.
|
||||
- the reclaimable bytes, the sum of `size` over all rows, leaving out a row
|
||||
whose `dupe` lies inside another row's `dupe`.
|
||||
|
||||
```
|
||||
trees: 14 records read, 1 duplicate tree groups, 1 dupe trees, 3.0 KiB reclaimable
|
||||
@@ -889,10 +858,8 @@ trees: 14 records read, 1 duplicate tree groups, 1 dupe trees, 3.0 KiB reclaimab
|
||||
### `dwim` mode
|
||||
|
||||
`dwim`, short for "do what I mean", scans a new machine and reports its
|
||||
duplicate trees in one command. 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. Like `scan`, it should run as root, so that it can read every
|
||||
file.
|
||||
duplicate trees in one command. It takes no positional arguments. Like `scan`,
|
||||
it should run as root, so that it can read every file.
|
||||
|
||||
`dwim` takes these flags of `scan`, with the same meaning (see "Settings"):
|
||||
|
||||
@@ -1294,8 +1261,7 @@ showing the count it stopped at.
|
||||
- `scan` with no operand;
|
||||
- `--workers` below 1;
|
||||
- an empty `--exclude` value, as in `--exclude ""`;
|
||||
- an empty `PATH` for `report` or `trees`, as in `sfdupes report ""`;
|
||||
- `info` or `dwim` with a positional argument.
|
||||
- `report`, `trees`, `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
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
the tracker yet is filed as an issue first.
|
||||
- Branch from `next`.
|
||||
- Do the work, with tests, in small focused commits.
|
||||
- Delete Next Step from `TODO.md`, in the same commit as the work.
|
||||
- Record the step at the top of Completed Steps, in the same commit as the work.
|
||||
- Push the branch and open a PR against `next`. Its title ends with
|
||||
` (closes #N)`.
|
||||
- An independent review gates each merge to `next`. Every finding is addressed
|
||||
@@ -15,7 +15,8 @@
|
||||
|
||||
- Pre-1.0.
|
||||
- The tracker is authoritative for the pre-1.0 backlog. The open issues under
|
||||
the `1.0.0` milestone are what remains before the tag.
|
||||
the `1.0.0` milestone are what remains before the tag. This file records
|
||||
history and process, not the queue.
|
||||
|
||||
# Next Step
|
||||
|
||||
@@ -23,6 +24,775 @@
|
||||
https://git.eeqj.de/sneak/sfdupes/milestone/17. The issues are not restated
|
||||
here, because a copy drifts as soon as the tracker moves.
|
||||
|
||||
# Completed Steps
|
||||
|
||||
Newest first. An entry ends with its date and its issue or branch, where those
|
||||
are known.
|
||||
|
||||
- The reclaimable total of `trees` is the sum of `size` over all rows, leaving
|
||||
out a row whose `dupe` lies inside another row's `dupe`. Before, such a row's
|
||||
bytes were counted again in each row whose `dupe` holds it (2026-11-11,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/168)
|
||||
- `dwim` takes the `scan` flags `--workers`, `-x`, `--no-default-excludes` and
|
||||
`--exclude`, with the same meaning. Both commands register and check them with
|
||||
the same code (2026-11-11, https://git.eeqj.de/sneak/sfdupes/issues/162)
|
||||
|
||||
- The help of `sfdupes` and of `scan` names the database, its default path and
|
||||
`SFDUPES_DATABASE`. The help of `report` and `trees` lists the columns, the
|
||||
order of the rows and the escapes. The help of `info` lists its lines. The
|
||||
help of `dwim` says that it scans `/`, should run as root and keeps the scan
|
||||
in the database (2026-11-11, https://git.eeqj.de/sneak/sfdupes/issues/177)
|
||||
- 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`
|
||||
operand is still a fatal error (2026-11-11,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/173)
|
||||
- The usage line of `scan` no longer ends in `[flags]`. It is the line
|
||||
`README.md` shows under "Subcommands" (2026-11-11,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/169)
|
||||
- `report` and `trees` leave out empty files. `report` writes no group of size
|
||||
0, and `trees` writes no group whose trees hold 0 bytes. An empty file still
|
||||
counts toward a tree's digest (2026-11-11,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/178)
|
||||
- The Go code moved out of the repository root. `cmd/sfdupes/main.go` is the
|
||||
command, and it calls `Main` in the package `internal/sfdupes`. `main.go`
|
||||
became `internal/sfdupes/cli.go`. Every other file kept its name. The install
|
||||
path is now `sneak.berlin/go/sfdupes/cmd/sfdupes` (2026-11-10,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/157)
|
||||
|
||||
- New subcommand `dwim`. It runs what `sfdupes scan /` runs with no flags, then
|
||||
what `sfdupes trees` runs. Its last line on stderr says that `sfdupes trees`
|
||||
prints the report again (2026-11-06,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/154)
|
||||
|
||||
- `scan` resolves each operand to its real path, symlinks followed, before the
|
||||
walk. A symlink operand is scanned at its target instead of skipped. With
|
||||
`/srv/link` a symlink to a directory outside `/srv`, `scan /srv /srv/link/sub`
|
||||
walks `sub` on its own instead of dropping it and deleting its records
|
||||
(2026-11-06, https://git.eeqj.de/sneak/sfdupes/issues/144)
|
||||
|
||||
- `README.md` and a comment in `internal/sfdupes/scan.go` no longer say ZFS
|
||||
counts a new file's blocks only seconds after the write. The count can land in
|
||||
under a second. Both now say up to seconds after the write, as the comment on
|
||||
`diskSizeOf` in `internal/sfdupes/scan_test.go` does (2026-11-03,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/152)
|
||||
|
||||
- The three disk size tests in `internal/sfdupes/scan_test.go` no longer fail at
|
||||
random on ZFS. `unix.Sync` can return before ZFS has counted a file's blocks,
|
||||
and one ZFS commit can take a file through several sizes. The test that needs
|
||||
the size to change waits for it, for at most 30 seconds. Each test reads the
|
||||
size before and after its scan. The rewrite test rescans until the two reads
|
||||
match, then compares exactly. The other two fail only on a `disk_size` outside
|
||||
the two reads (2026-11-02, https://git.eeqj.de/sneak/sfdupes/issues/150)
|
||||
|
||||
- `TODO.md` rewritten from scratch by the same rules as `README.md`, sentence by
|
||||
sentence. Every completed step is kept, with its date and its issue or branch.
|
||||
The policy-compliance checklist of 2026-07-22 is folded into its step
|
||||
(2026-11-02, https://git.eeqj.de/sneak/sfdupes/issues/135)
|
||||
|
||||
- `README.md` rewritten from scratch, sentence by sentence, as a newcomer reads
|
||||
it. It leads with what the program is and how to use it. A reference section
|
||||
covers every setting and every subcommand. Development and testing come last.
|
||||
Every statement was checked against the code on `next`. Five comments in
|
||||
`internal/sfdupes/cli_test.go` cite "Settings", where their rules now live.
|
||||
One comment each in these files cites what the README now says:
|
||||
- `internal/sfdupes/scan_test.go`;
|
||||
- `internal/sfdupes/trees_test.go`;
|
||||
- `internal/sfdupes/exclude_test.go`.
|
||||
|
||||
(2026-11-02, https://git.eeqj.de/sneak/sfdupes/issues/135)
|
||||
|
||||
- Each record holds `disk_size`, the bytes the file takes on disk. That is its
|
||||
allocated blocks, `st_blocks` × 512, from the `lstat` call the walk already
|
||||
makes. `trees` prints a `disk_size` column after `size`. It is the sum over
|
||||
the `dupe` copy's files. On a compressed or sparse file `disk_size` differs
|
||||
from `size`. A rescan updates the `disk_size` of an unchanged file whose size
|
||||
on disk changed, without reading the file (2026-10-27,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/147)
|
||||
|
||||
- The database keeps the number of records and the sum of their sizes in the one
|
||||
row of a `totals` table. Three triggers on `files` keep that row current.
|
||||
`info` reads that row. So do `scan`'s `load` phase and the `read` phases of
|
||||
`report` and `trees`, for their totals. No count reads every record any more.
|
||||
The triggers make each write to `files` slower. `scan` keeps SQLite's
|
||||
temporary data in memory. That wins back part of that time (2026-10-27,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/146)
|
||||
|
||||
- an operand at or inside a directory named `.zfs` is never scanned, whether
|
||||
given alone or under another operand. `scan` warns about it, counts it as
|
||||
skipped and does not walk it (2026-10-26,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/142)
|
||||
|
||||
- A file or directory removed while the scan runs is not an error, in the walk
|
||||
or in the hash phase. The scan prints no line for it and does not count it as
|
||||
skipped. When the first of several hard links to a file is gone, the hash
|
||||
phase reads the next one instead. On a terminal every progress display starts
|
||||
with the spinner, the hash phase's included. A phase with an exact total ends
|
||||
its line with its percent and a 10-column bar at the terminal's right edge.
|
||||
The bar no longer moves as the line's length changes. A line too wide for the
|
||||
terminal now loses its rate before its bar. The time remaining is labelled
|
||||
`remain`, not `eta` (2026-10-26, https://git.eeqj.de/sneak/sfdupes/issues/133)
|
||||
|
||||
- The `head`, `tail` and `content` columns are BLOBs, each holding the raw 32
|
||||
bytes of a SHA-256. That is half the size of the hex text they held. The
|
||||
hashes stay raw from the hash phase through the database to `report` and
|
||||
`trees`. Reading a record whose hash is not 32 bytes is an error (2026-10-26,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/134)
|
||||
|
||||
- The hash phase gives three hashes to every file that the walk records. `head`
|
||||
and `tail` are the SHA-256 of its first and last 64 KiB. `content` is the
|
||||
SHA-256 of the whole file under 100 MiB, and of 1 MiB at each gigabyte from
|
||||
100 MiB up. Gone are:
|
||||
- the 10 MiB and 50 MiB thresholds;
|
||||
- the size census, which counted the sizes of every walked file and of every
|
||||
record outside the operands. A file was hashed only when the census showed
|
||||
another file of its size;
|
||||
- the records without hashes;
|
||||
- the content phase.
|
||||
|
||||
A scan has four phases, and a rescan reads only new and changed files.
|
||||
`info` no longer counts the records with `head` and `tail` hashes, nor those
|
||||
with a content hash, since every record has all three (2026-10-25,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/132)
|
||||
|
||||
- `REPO_POLICIES.md` and the four scripts that pass `CACHEBUST` were copied
|
||||
again from `sneak/prompts` `next` at `0653579`. Two steps now come before
|
||||
`ARG CACHEBUST`:
|
||||
- the module download in the `lint`, `test` and `builder` stages of the
|
||||
`Dockerfile`;
|
||||
- the package install in `builder`.
|
||||
|
||||
Docker keeps them until one of these changes:
|
||||
- the base image;
|
||||
- the install line;
|
||||
- `go.mod` or `go.sum`.
|
||||
|
||||
Every step that checks or compiles the code still comes after
|
||||
`ARG CACHEBUST`. `golangci-lint run` also keeps the linter's own cache.
|
||||
README says the same (2026-10-18,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/109)
|
||||
|
||||
- The release rule was set. Until 1.0, each tip of `main` that passes the build
|
||||
gets the next `v0.0.N` tag.
|
||||
`go install sneak.berlin/go/sfdupes/cmd/sfdupes@latest` then installs it.
|
||||
`go.mod` retracts `v0.0.1`, the early build without a database. When the
|
||||
linker set no version, `sfdupes --version` prints the version Go recorded in
|
||||
the binary. That is the tag, or the pseudo-version of a `go install` build. It
|
||||
prints `dev` only when neither is known. README "Install" documented:
|
||||
- the rule;
|
||||
- what `@main` and `v0.0.1` give;
|
||||
- how to check an installed binary.
|
||||
|
||||
(2026-10-17, https://git.eeqj.de/sneak/sfdupes/issues/116)
|
||||
|
||||
- `scan` creates the database's directory where the database path leads. The
|
||||
directory is the path with its last element cut off as text, so a `..` in it
|
||||
stays. A `..` after a symlinked directory therefore goes through the symlink,
|
||||
as it does when the file is opened. With
|
||||
`SFDUPES_DATABASE=/srv/link/../new/db.sqlite` and `/srv/link` a symlink to
|
||||
`/data/x`, it now creates `/data/new` and the database in it. It used to
|
||||
create `/srv/new` and then fail (2026-10-17,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/119)
|
||||
|
||||
- `scan` never records its own database. Once the database and its `.lock` file
|
||||
are open, it notes the device and inode of each of these:
|
||||
- the database file;
|
||||
- its `-wal` and `-shm` files;
|
||||
- the `.lock` file.
|
||||
|
||||
The walk passes over any file with the device and inode of one of them,
|
||||
however it reaches the file. It prints no line for such a file and counts
|
||||
nothing. A record an earlier scan left for one of them is deleted
|
||||
(2026-10-17, https://git.eeqj.de/sneak/sfdupes/issues/115)
|
||||
|
||||
- `scan` never records or reads anything on a filesystem that is not persistent,
|
||||
such as `tmpfs` or `proc`. Such a filesystem is one the kernel makes up or
|
||||
keeps in memory. `scan` matches them by device ID, however the walk or the
|
||||
content phase reaches a path. As the scan starts, it lists the mounted
|
||||
filesystems of those types, from `/proc/self/mountinfo` on Linux and from the
|
||||
mount list on macOS. No flag turns that off. Below an operand, the walk does
|
||||
not enter the default excludes either. So `sfdupes scan /` skips the kernel's
|
||||
view of the running system and the temporary directories. On Linux those are:
|
||||
|
||||
```
|
||||
/proc, /sys, /dev, /run, /tmp, /var/tmp
|
||||
```
|
||||
|
||||
On macOS they are:
|
||||
|
||||
```
|
||||
/dev, /private/tmp, /private/var/tmp, /private/var/vm
|
||||
/System/Volumes/VM, /System/Volumes/Data
|
||||
```
|
||||
|
||||
A Windows list exists in the code but is not used. An operand at or inside a
|
||||
default exclude is still walked. The scan prints a line for each path it
|
||||
leaves out, without counting it as skipped. The records there count as
|
||||
outside the scanned operands, as for `-x`. `--no-default-excludes` turns off
|
||||
the default excludes only, and `scan --help` lists them (2026-10-17,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/124)
|
||||
|
||||
- A progress display's rate covers the items completed over the last 5 seconds.
|
||||
When stderr is not a terminal, it covers the items since the line before. It
|
||||
falls to 0 while nothing completes. A burst after a wait no longer reads as a
|
||||
steady rate of over 1,000 files a second. The time remaining still comes from
|
||||
the phase's average. Once no item has completed for 10 seconds, the line shows
|
||||
`stalled` and where the phase waits in place of the rate, as
|
||||
`stalled disk/db`. The places are:
|
||||
- `disk`;
|
||||
- `db`;
|
||||
- `out`, for stdout;
|
||||
- `cpu`.
|
||||
|
||||
A phase that may wait in two places names both. Each phase's word is set in
|
||||
the code that defines the phase. A line too wide for the terminal loses its
|
||||
bar first, then its rate or those words. Four parts stay whole:
|
||||
- the phase;
|
||||
- the progress;
|
||||
- the elapsed time;
|
||||
- the ETA, the time remaining.
|
||||
|
||||
The content phase had one display for its checks and one for its reads. Both
|
||||
lost those words on an 80-column terminal, at counts like those of README's
|
||||
example. That happened for most elapsed times and ETAs in minutes. Every
|
||||
other phase kept them whenever the elapsed time and the ETA were both in
|
||||
minutes. The content phase writes its last partial batch, the records not
|
||||
yet written, under a display of its own (2026-10-16,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/125)
|
||||
|
||||
- New subcommand `info` prints the database's details on stdout, one per line as
|
||||
a name, a tab and the value:
|
||||
- the path and where it came from;
|
||||
- the sizes of the database file and of its `-wal` file, when there is one;
|
||||
- when the database file was last changed;
|
||||
- the schema version;
|
||||
- the number of records;
|
||||
- how many records have `head` and `tail` hashes;
|
||||
- how many records have a content hash;
|
||||
- the sizes of all records added up.
|
||||
|
||||
It opens the database as `report` does and shows two phases on stderr,
|
||||
`[1/2] open` and `[2/2] count`. The schema version and the counts come from
|
||||
one read-only transaction, a read of the database at one moment. The counts
|
||||
come from one query (2026-10-16,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/117)
|
||||
|
||||
- `report` shows its work on stderr in two phases, `[1/2] open` and
|
||||
`[2/2] read`, with the progress display `scan` and `trees` use. The display
|
||||
runs from the moment `report` starts until the summary line. `open` says it is
|
||||
opening the database, also while it waits on a busy one. `read` counts the
|
||||
records, then reads them against that count in signature order. SQLite takes
|
||||
that order from the `files_signature` index without sorting, so the first
|
||||
record comes at once. `report` forms the duplicate groups itself and holds
|
||||
only those of the size it is reading. It writes them ordered by first path
|
||||
before it reads the next size. stdout and the summary line are unchanged, and
|
||||
SQLite no longer needs a temporary file to sort in (2026-10-16,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/114)
|
||||
|
||||
- `trees` shows its work on stderr in four phases, from `[1/4] open` to
|
||||
`[4/4] write`, each with the progress display `scan` uses. The display runs
|
||||
from the moment `trees` starts until the summary line. `open` says it is
|
||||
opening the database, also while it waits on a busy one. `read` counts the
|
||||
records, then reads them against that count. `group` counts the directories it
|
||||
groups, and `write` the groups it writes. A display's rate names what its
|
||||
phase counts:
|
||||
- files;
|
||||
- records;
|
||||
- directories;
|
||||
- groups.
|
||||
|
||||
stdout and the summary line are unchanged. When stdout and stderr are the
|
||||
same file, as one terminal is, no line of stdout shares a line with the
|
||||
display. When they are not, the display keeps being drawn while stdout waits
|
||||
on a slow reader (2026-10-16, https://git.eeqj.de/sneak/sfdupes/issues/113)
|
||||
|
||||
- Each `scan` phase's progress display names the phase and its place among the
|
||||
five, as `[2/5] walk`. It runs from the moment that the phase starts. It
|
||||
shows:
|
||||
- the progress;
|
||||
- the elapsed time;
|
||||
- the ETA, the time remaining.
|
||||
|
||||
`load` counts the records first. The walk's total is estimated from the
|
||||
records under the operands. The content phase takes its total from SQLite's
|
||||
grouping alone. Until the first record is returned, it says it is searching
|
||||
the database. On a terminal a phase with an exact total draws its line
|
||||
followed by the bar of the progress-bar library. Any other phase draws a
|
||||
spinner followed by the line. Every display is drawn again several times a
|
||||
second. No line reaches the terminal's last column, however narrow the
|
||||
terminal is, even after it is made narrower during a phase. A line too wide
|
||||
leaves out its rate, then its bar. The rest stays whole. The line is cut
|
||||
short only when the rest alone does not fit, as below about 70 columns late
|
||||
in a large scan. When stderr is not a terminal, the line is printed every 5
|
||||
seconds whether or not an item completed (2026-10-16,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/112)
|
||||
|
||||
- `scan`, `report` and `trees` first print a line on stderr naming the database
|
||||
they use, as an absolute path. The line says whether that path is the default
|
||||
or comes from `SFDUPES_DATABASE`. `scan` says when the database is new. README
|
||||
"Database" says when `scan` writes each file (2026-10-16,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/111)
|
||||
|
||||
- The canonical files and model scripts were copied again from `sneak/prompts`
|
||||
`next` at `e3f79c4`:
|
||||
- `golangci-lint` v2.14.0;
|
||||
- lint and test are phases of the `Dockerfile` that write no image, and
|
||||
`make test` runs the suite under the race detector. Gone are
|
||||
`Dockerfile.lint`, `script/verify-lint-image-pin` and `make test-race`;
|
||||
- every `docker build` in `script/` passes a new `CACHEBUST` value. Every
|
||||
stage of the `Dockerfile` declares it first, so every `RUN` step runs on
|
||||
every build. The steps that compile keep Go's build cache, and the tests
|
||||
run with `-count=1`;
|
||||
- `prettier` runs on the host, from the `node` and `yarn` that
|
||||
`script/bootstrap` installs. The `prettier` and `markdown` stages are
|
||||
gone, and the build stage installs `git` and `make` itself;
|
||||
- a new push cancels the workflow's older run on the same branch, and a run
|
||||
stops after 20 minutes;
|
||||
- a coding agent's settings file is deleted.
|
||||
|
||||
Since https://git.eeqj.de/sneak/sfdupes/issues/109 two steps come before
|
||||
`ARG CACHEBUST`:
|
||||
- the module download in `lint`, `test` and the build stage;
|
||||
- the install of `git` and `make` in the build stage.
|
||||
|
||||
Docker keeps them between builds. Every step that checks or compiles the
|
||||
code still runs on every build (2026-10-15,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95)
|
||||
|
||||
- With `-x`, an operand under another operand is no longer dropped when a
|
||||
directory between the two, the inner one included, is on a different
|
||||
filesystem than the outer one. The inner operand is then walked on its own.
|
||||
For a regular-file operand the check starts at its directory. The records of
|
||||
files gone from below it are deleted (2026-10-14,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/106)
|
||||
|
||||
- With `-x`, `scan` keeps the records below a directory on another filesystem
|
||||
under its operand, instead of deleting them. It counts their sizes in the size
|
||||
census (2026-10-14, https://git.eeqj.de/sneak/sfdupes/issues/99)
|
||||
|
||||
- The hash and content phases open each file without blocking and check that it
|
||||
is still a regular file. A file that is now a FIFO or device node is warned
|
||||
about and skipped instead of hanging the scan (2026-10-14,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/100)
|
||||
|
||||
- The scan lock file is named from the database's path with symlinks resolved,
|
||||
after `scan` creates the database file if it is missing. A scan through a
|
||||
symlink to the database therefore fails while another scan holds the lock
|
||||
(2026-10-14, https://git.eeqj.de/sneak/sfdupes/issues/101)
|
||||
|
||||
- On a terminal, a warning for the last file of a phase no longer erases the
|
||||
phase's finished bar. The bar is drawn again below the warning (2026-10-14,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/102)
|
||||
|
||||
- `scan` records the mtime to the nanosecond, as whole seconds in `mtime` plus
|
||||
`mtime_nsec`, and compares it at that resolution. A same-size rewrite within
|
||||
the same second is hashed again (2026-10-07,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/12)
|
||||
|
||||
- The narration was cut from `TODO.md` Completed Steps and from the comments in
|
||||
`script/`, `Dockerfile` and `Dockerfile.lint` (gone since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95). The Workflow section now
|
||||
branches from and merges to `next` (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/49)
|
||||
|
||||
- `make test-race` ran the test suite under the race detector in a cgo-enabled
|
||||
container, outside `make check`. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 `make test` itself runs the suite
|
||||
under the race detector, in the `Dockerfile`'s Debian-based `test` phase.
|
||||
`make test-race` is gone (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/18)
|
||||
|
||||
- A bare `docker build .` failed, naming `script/cibuild` and `script/docker`,
|
||||
rather than serve the gates, the lint and test steps, from cache. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 a bare build succeeds, as
|
||||
`REPO_POLICIES.md` requires, and may serve the gates from cache. The builds in
|
||||
`script/` pass a new `CACHEBUST` value, so theirs always run (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/39)
|
||||
|
||||
- `make fmt` and `make fmt-check` run `prettier` over all Markdown, and the
|
||||
Gitea workflow checks it. All Markdown was reformatted (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/19)
|
||||
|
||||
- `script/lint` writes no image, so a run no longer leaves an untagged one
|
||||
behind (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/48)
|
||||
|
||||
- Tests cover:
|
||||
- a missing database;
|
||||
- `scan` keeping stdout empty;
|
||||
- its skip warning;
|
||||
- the `report` and `trees` summary lines;
|
||||
- every subcommand going through `runE`.
|
||||
|
||||
(2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/16)
|
||||
|
||||
- `.golangci.yml` was replaced with the current canonical copy, which uses
|
||||
`gomodguard_v2`, so lint no longer prints a deprecation warning (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/26)
|
||||
|
||||
- A test fails when either `hashWorker` cancellation check in
|
||||
`internal/sfdupes/scan.go` is removed (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/83)
|
||||
|
||||
- A database path holding `?`, `#` or `%` opens exactly the file it names
|
||||
(2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/55)
|
||||
|
||||
- `scan` rejects `--workers` below 1 as a usage error instead of running
|
||||
single-threaded (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/10)
|
||||
|
||||
- A test fails when either walk cancellation check in `internal/sfdupes/scan.go`
|
||||
is removed (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/81)
|
||||
|
||||
- A test checks that `scan` refuses a database with another schema version
|
||||
(2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/64)
|
||||
|
||||
- Four inaccurate comments in `internal/sfdupes/cancel_test.go` were corrected,
|
||||
and `walkCancelInFlightDirs` was renamed to `walkCancelInFlightFiles`
|
||||
(2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/33)
|
||||
|
||||
- The `-x` filesystem-boundary rules in `subdirJob` are tested (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/17)
|
||||
|
||||
- `scan` creates the schema in one transaction. A version-0 database with a
|
||||
`files` table is refused with a clear schema-version error (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/11)
|
||||
|
||||
- README documents install, Docker, a daily `cron` scan and how to read and
|
||||
check the reports (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/54)
|
||||
|
||||
- The `Dockerfile` build stage kept the Go module cache out of `builder`'s home
|
||||
and copied the sources with `--chown`, so no `chown -R` walked them. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 there is no `builder` user and
|
||||
nothing changes owner. The build stage only compiles, as root, and the tests
|
||||
run as `nobody` in the `test` phase (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/43)
|
||||
|
||||
- `--version` prints `sfdupes VERSION` to stdout. README documents it and
|
||||
`--help` (2026-10-04, https://git.eeqj.de/sneak/sfdupes/issues/15)
|
||||
|
||||
- `scan` stops cleanly on `SIGINT` or `SIGTERM`: it commits what it has hashed,
|
||||
deletes nothing more, and exits 1 (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/5)
|
||||
|
||||
- `report` and `trees` stream the records instead of holding them all in memory.
|
||||
The schema gains the `files_signature` index (2026-10-04,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/14)
|
||||
|
||||
- Progress prints at once on a non-terminal and uses a real terminal test.
|
||||
Warnings print through a spinner instead of racing its redraw (2026-10-03,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/13)
|
||||
|
||||
- These operands are warned about and skipped, and the records beneath them are
|
||||
kept:
|
||||
- symlinks;
|
||||
- sockets;
|
||||
- FIFOs;
|
||||
- device nodes;
|
||||
- `.zfs` directories.
|
||||
|
||||
(2026-10-03, https://git.eeqj.de/sneak/sfdupes/issues/9)
|
||||
|
||||
- `scan` holds a lock on a lock file beside the database for its whole run, so a
|
||||
second `scan` fails at once with exit 1 (2026-10-03,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/53)
|
||||
|
||||
- Tests cover stdout write failures in `report` and `trees`. README states that
|
||||
`| head` ends `sfdupes` by `SIGPIPE` and that `>&-` writes to `/dev/null`
|
||||
(2026-10-03, https://git.eeqj.de/sneak/sfdupes/issues/30)
|
||||
|
||||
- `report` and `trees` open the database read-only, and `scan` leaves it out of
|
||||
WAL mode, so reading needs only read access (2026-10-03,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/8)
|
||||
|
||||
- Four characters are escaped in `report`, `trees` and warning paths:
|
||||
- tab;
|
||||
- newline;
|
||||
- carriage return;
|
||||
- backslash.
|
||||
|
||||
The root directory's path is `/` (2026-10-03,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/7)
|
||||
|
||||
- A plain `docker build .` stamps the `git` tag or short commit instead of
|
||||
`dev`. `.dockerignore` sends `.git` without `.git/config`. The build stage
|
||||
stamps the `VERSION` build argument, else `git describe --tags --always`. It
|
||||
fails if the context carries `.git` and the version is still empty, `dev` or
|
||||
`unknown`. The Gitea workflow checks out the full history (`fetch-depth: 0`),
|
||||
so it stamps the same value as `make build` (2026-10-02, branch `next`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/67)
|
||||
|
||||
- The 1 KiB end-window sampling was replaced with the hashes chosen by file
|
||||
size, and README "Duplicate detection" documented every size threshold. A file
|
||||
under 10 MiB was hashed in full, and its `head`, `tail` and `content` all held
|
||||
that hash. A larger file got only its 64 KiB `head` and `tail` in the hash
|
||||
phase. The content phase ran after the update phase. It read a file for
|
||||
`content` only when its size, `head` and `tail` matched another record's, from
|
||||
this scan or an earlier one. `content` was the whole file below 50 MiB, and
|
||||
gigabyte-spaced 1 MiB samples at or above. It never read a file gone or
|
||||
changed since its record was written. `report` and `trees` left out any record
|
||||
without a `content` hash. The `content` column is part of the version 1
|
||||
schema. Superseded by https://git.eeqj.de/sneak/sfdupes/issues/132
|
||||
(2026-09-22, branch `next`, https://git.eeqj.de/sneak/sfdupes/issues/61)
|
||||
|
||||
- The dead `files.dat` references were removed from `Makefile`, `.gitignore` and
|
||||
`.dockerignore` (2026-09-21, branch `next`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/22)
|
||||
|
||||
- The lint-image pin comments and `FROM` form in `Dockerfile` and
|
||||
`Dockerfile.lint` were fixed. Both pins became the policy
|
||||
`# image:vX.Y.Z, YYYY-MM-DD` comment over a bare `FROM image@sha256:...`,
|
||||
without the false `(Debian-based)` note or the tag. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 the `Dockerfile`'s `lint` phase
|
||||
holds the only `golangci-lint` pin, in that form. `Dockerfile.lint` is gone,
|
||||
and so is `script/verify-lint-image-pin`, which compared the two pins
|
||||
(2026-08-10, branch `next`, https://git.eeqj.de/sneak/sfdupes/issues/25)
|
||||
|
||||
- All linting ran in Docker, via `Dockerfile.lint` and `script/lint`. Per the
|
||||
owner ruling the linter is never installed on a host, and
|
||||
`golangci-lint config verify` runs before `golangci-lint run`.
|
||||
`script/bootstrap` stopped installing or pinning the linter, and
|
||||
`script/verify-linter-pin` was retired. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 both commands run in the
|
||||
`Dockerfile`'s `lint` phase. `script/lint` builds that phase alone, and the
|
||||
build stage depends on it through `COPY --from=lint /src/go.sum /dev/null`.
|
||||
`Dockerfile.lint` and `script/verify-lint-image-pin` are gone. Nothing inside
|
||||
an image build may run `docker`, so the phase calls `golangci-lint` directly
|
||||
(2026-08-10, branch `next`, https://git.eeqj.de/sneak/sfdupes/issues/46)
|
||||
|
||||
- The Docker build stage's prerequisites were installed by running
|
||||
`script/bootstrap` instead of `apk add --no-cache make` inline.
|
||||
`script/verify-linter-pin` failed the build unless the linter copied from the
|
||||
lint stage was the version that `script/bootstrap` pinned. Builds then took up
|
||||
to 5m14s from an empty cache, mostly in a `chown -R` of the module cache,
|
||||
filed as https://git.eeqj.de/sneak/sfdupes/issues/43. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 the build stage installs `git` and
|
||||
`make` with `apk add --no-cache` and only compiles. The `lint` and `test`
|
||||
phases are the gates (2026-08-09, branch `dockerfile-bootstrap`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/42)
|
||||
|
||||
- The Docker layer cache is defeated for the gate steps, so `script/cibuild` and
|
||||
`script/docker` cannot report a pass they did not earn. The `Dockerfile`
|
||||
copies the tree before its gates. On an unchanged tree Docker served them from
|
||||
cache, and the build exited 0 without running them. The fix was a
|
||||
`CHECK_EPOCH` build argument. Since
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/95 every `docker build` in `script/`
|
||||
passes a new `CACHEBUST` value instead. Every stage of the `Dockerfile`
|
||||
declares it before every step that checks or compiles the code. Run as root,
|
||||
the tests fail `TestScanHardlinkRunFailsTogether`, because root reads through
|
||||
the `chmod(0)` the test relies on. So the `test` phase runs them as `nobody`
|
||||
(2026-08-09, branch `cibuild-cache-bust`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/32)
|
||||
|
||||
- `script/bootstrap` checked the installed `golangci-lint` version instead of
|
||||
only its presence. The version lived only in `GOLANGCI_LINT_VERSION`, with the
|
||||
`go install` module reference derived from it. Any installed version that was
|
||||
not the pin was reinstalled, whether:
|
||||
- older;
|
||||
- newer;
|
||||
- absent;
|
||||
- unparseable.
|
||||
|
||||
`go install` writes into `GOBIN`, or `GOPATH/bin`, while `make lint` ran the
|
||||
first `golangci-lint` on `PATH`. So bootstrap re-read the effective version
|
||||
after installing. On a mismatch it printed both paths and both versions and
|
||||
exited non-zero. It did not reorder `PATH` or delete anyone's binary. The
|
||||
`--version` call kept its stderr and was bounded by `timeout(1)` where that
|
||||
exists. `git`, `make` and `go` kept presence-only checks. The version check
|
||||
was verified by bootstrapping this host from v2.10.1 to v2.12.2, and again
|
||||
to a no-op. Stub runs of the script under `dash` covered:
|
||||
- a thirteen-input version-parse matrix;
|
||||
- a shadowed install, which must exit non-zero;
|
||||
- an install destination not on `PATH`;
|
||||
- `GOBIN` set;
|
||||
- a wedged binary, which must hit the timeout.
|
||||
|
||||
`make check` and `make lint` were clean at v2.12.2, so v2.10.1 had not been
|
||||
hiding findings on `main`. Superseded by
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/46, since the linter is no longer
|
||||
installed on a host (2026-08-09, branch `bootstrap-version-check`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/24)
|
||||
|
||||
- The hash worker pool unwinds on the error path. The pool is an owned,
|
||||
context-aware `hashPool`. Every blocking send in the feeder and the workers
|
||||
selects on `ctx.Done()`, and `jobs` is closed on every path out. `hashPhase`
|
||||
defers `pool.stop()`, which cancels and then drains `results` until the last
|
||||
goroutine has exited. Draining is what frees a worker parked on a send. `ctx`
|
||||
is passed from `cmd.Context()` as the first parameter, through:
|
||||
- `runScan`;
|
||||
- `syncScan`;
|
||||
- both worker pools;
|
||||
- the whole database layer.
|
||||
|
||||
The walk pool gets the same treatment, plus a `ctx.Err()` guard after the
|
||||
walk. A cancelled walk yields a partial size census, and every file that it
|
||||
never reached looks vanished to the update phase. That phase's own `BeginTx`
|
||||
also fails on the cancelled context before deleting anything. The guard is
|
||||
still the barrier once an interrupted scan may commit what it has. Tests
|
||||
drive `run(scan)` against a database whose insert trigger aborts. They
|
||||
assert that the scan fails instead of hanging, and that the goroutine count
|
||||
returns to its pre-scan baseline. Other tests cancel a scan part-way through
|
||||
the walk, deterministically, by counting the scan's own checks of
|
||||
`ctx.Done()`. They assert that it stops at the guard with every record
|
||||
intact. It then holds a partial size census and a still-populated record
|
||||
index. Direct tests cover the remaining cancellation branches of both pools.
|
||||
They test:
|
||||
- `sendEvent`;
|
||||
- the walk workers;
|
||||
- `dispatchDirs`;
|
||||
- `feedHashJobs`;
|
||||
- `hashWorker`;
|
||||
- `hashPhase`.
|
||||
|
||||
(2026-08-09, branch `hash-pool-cleanup`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/6)
|
||||
|
||||
- The database is closed on every fatal exit path. `fatalf` and its `os.Exit(1)`
|
||||
are gone. So the deferred `db.Close()` runs when a subcommand fails, and with
|
||||
it the SQLite WAL checkpoint. These return errors instead:
|
||||
- `runScan`;
|
||||
- `runReport`;
|
||||
- `runTrees`;
|
||||
- `loadRecords`;
|
||||
- `resolveRoots`.
|
||||
|
||||
The single exit point is `run` in `internal/sfdupes/cli.go`. It maps a
|
||||
`fatalError`, anything a subcommand returned, to exit 1, and cobra's own
|
||||
argument and flag errors to exit 2. So a runtime failure is never reported
|
||||
as a usage error, nor printed with the usage text.
|
||||
`internal/sfdupes/cli_test.go` drives the CLI in-process and asserts the
|
||||
exit codes from README "Error handling" and the stdout/stderr split. It also
|
||||
checks that a fatal error after the database is open leaves no `-wal` or
|
||||
`-shm` file behind, for `scan`, `report` or `trees` (2026-08-09, branch
|
||||
`db-close-on-fatal`, https://git.eeqj.de/sneak/sfdupes/issues/4)
|
||||
|
||||
- `golangci-lint` was updated to v2.12.2 with the canonical config, merged as
|
||||
`38a01bd`. The pinned linter in the `Dockerfile` lint stage and
|
||||
`script/bootstrap` went from v2.12.1 to v2.12.2, and `.golangci.yml` was
|
||||
replaced with the canonical file. Four thresholds now live under
|
||||
`linters.settings`, as the v2 schema requires, so they are applied:
|
||||
- `lll`;
|
||||
- `funlen`;
|
||||
- `cyclop`;
|
||||
- `dupl`.
|
||||
|
||||
No new lint findings surfaced (2026-08-09, branch `golangci-v2.12.2`,
|
||||
https://git.eeqj.de/sneak/sfdupes/issues/3)
|
||||
|
||||
- `Makefile` targets were converted to scripts-to-rule-them-all `script/`
|
||||
entrypoints, like the other managed repos. All 12 entrypoints exist:
|
||||
- `bootstrap`, `setup` and `projectname`;
|
||||
- `test`, `lint`, `fmt`, `fmt-check` and `check`;
|
||||
- `docker`, `cibuild`, `precommit` and `install-precommit`.
|
||||
|
||||
Every `Makefile` target does nothing but call its script (2026-07-26, commit
|
||||
`3abeacf`, https://git.eeqj.de/sneak/sfdupes/issues/1)
|
||||
|
||||
- The binary is the default `make` target. Plain `make` builds `sfdupes`, where
|
||||
it used to run `check` plus `build`. `make build` remains as an alias
|
||||
(2026-07-24, branch `make-default-target`)
|
||||
|
||||
- The phases became scan-wide, with concurrent operands and batched updates. All
|
||||
operands seed the shared walk pool, and every pass runs once over the whole
|
||||
scan. So the totals and ETAs cover the whole scan. The per-operand walk, hash
|
||||
and update cycles and their stderr announcements are gone. The update pass
|
||||
writes in batches, each in its own transaction. The filesystem is
|
||||
authoritative and the database follows it, so one scan's changes need not land
|
||||
all at once (2026-07-24, branch `scan-wide-phases`)
|
||||
|
||||
- The stat pass was split back out of the walk. Phases are strictly sequential
|
||||
again, per operand, with parallelism only inside each phase:
|
||||
- walk;
|
||||
- stat;
|
||||
- hash;
|
||||
- update.
|
||||
|
||||
The walk enumerates paths with per-directory workers, and the stat pass
|
||||
lstats them with per-file workers. That restores the exact total and ETA of
|
||||
the stat bar (2026-07-24, branch `parallel-phases`)
|
||||
|
||||
- Each operand is announced on stderr before its passes. With per-operand walk,
|
||||
hash and update cycles, a multi-operand run such as `scan /srv/*` showed pass
|
||||
totals that looked like the whole run's (2026-07-24, branch
|
||||
`scan-operand-progress`)
|
||||
|
||||
- The walk became parallel. The walk pass was a single goroutine and took hours
|
||||
at about 20 million files on a busy pool. One ZFS server took 4 hours for 22
|
||||
million files. It is now a walk by a pool of per-directory workers that
|
||||
records size and mtime as it goes. That folds away the separate stat pass and
|
||||
halves the metadata reads. Each `PATH` operand commits in its own transaction,
|
||||
so an interrupted scan keeps completed operands (2026-07-24, branch
|
||||
`parallel-walk`)
|
||||
|
||||
- `scan` gained a persistent database. It maintains an SQLite database that
|
||||
survives between runs, with the absolute path as each record's key. The driver
|
||||
is `modernc.org/sqlite`, pure Go, so cgo stays disabled. A rescan hashes only
|
||||
new or changed files, by mtime and size. It deletes the records of files
|
||||
vanished from under the scanned operands and leaves records outside them
|
||||
untouched. So `scan` can run daily from `cron`. `report` and `trees` read the
|
||||
database, with no positional arguments, instead of a scan stream. The database
|
||||
is at `/var/lib/sfdupes/db.sqlite`, and `SFDUPES_DATABASE` overrides that. WAL
|
||||
journaling plus a single-transaction update keep a report run during a scan
|
||||
safe (2026-07-24, branch `persistent-database`)
|
||||
|
||||
- The `origin` remote, `git@git.eeqj.de:sneak/sfdupes.git`, was added. `v0.0.1`
|
||||
was tagged, and `main` and the tags were pushed (2026-07-23)
|
||||
|
||||
- The `scan` command line was reworked. Required `PATH...` operands, parsed by
|
||||
cobra, replace the `/srv` `-root` default. The new `-x`, `--one-file-system`
|
||||
flag follows the GNU convention and stops at filesystem boundaries, which the
|
||||
walk crosses by default (2026-07-23, branch `scan-required-paths`)
|
||||
|
||||
- The repo was brought into compliance with `REPO_POLICIES.md` (the version of
|
||||
2026-07-06), the existing repo checklist and the Go styleguide. The audit of
|
||||
2026-07-22 found these gaps, and the branch closed them:
|
||||
- `.gitignore`, with the standard patterns for secrets and for OS, editor
|
||||
and Go files. The compiled `sfdupes` binary and `files.dat` had been
|
||||
sitting untracked in the tree;
|
||||
- `.editorconfig`;
|
||||
- `LICENSE` and the README License section. MIT was assumed from house
|
||||
convention, for the owner to confirm;
|
||||
- `REPO_POLICIES.md` in the repo root;
|
||||
- the canonical `.golangci.yml`, with its 150 findings fixed, so that
|
||||
`make lint` is clean;
|
||||
- the `Makefile` targets the policy requires:
|
||||
- `test` and `lint`;
|
||||
- `fmt` and `fmt-check`;
|
||||
- `docker` and `hooks`.
|
||||
|
||||
`check` depended on `build`, which wrote the binary. `make check` must
|
||||
not modify files, so `check` no longer depends on `build`;
|
||||
|
||||
- a test suite, which the policy required with a 30-second timeout and the
|
||||
conditional `-v` rerun. At 64% coverage, it covers:
|
||||
- parsing and grouping;
|
||||
- digests and suppression;
|
||||
- hashing and the scan pipeline;
|
||||
- a multistage `Dockerfile` and `.dockerignore`. The `Dockerfile` had:
|
||||
- hash-pinned images;
|
||||
- a lint stage that failed fast;
|
||||
- a build stage that ran `make check`;
|
||||
- `.gitea/workflows/check.yml`, running `docker build .` on push with the
|
||||
checkout action pinned by commit SHA;
|
||||
- the README sections the policy requires. The first is a Description whose
|
||||
first line names the project, its purpose and category, its license and
|
||||
its author. Then come Getting Started and Rationale, and at the end TODO,
|
||||
License and Author;
|
||||
- the stale README non-goal "no git repository setup and no CI" removed;
|
||||
- the pre-commit hook, installed with `make hooks` once that target existed.
|
||||
|
||||
The code was already `gofmt`-clean, so no standalone formatting commit was
|
||||
needed (2026-07-23, branch `repo-policy-compliance`)
|
||||
|
||||
- `git init` was run, with a README-only first commit. The code baseline was
|
||||
committed on `main` (2026-07-22)
|
||||
|
||||
- The `scan`, `report` and `trees` subcommands were implemented (pre-git
|
||||
history)
|
||||
|
||||
# Future Steps
|
||||
|
||||
- Possible later features, out of scope per README, are a byte-for-byte check of
|
||||
|
||||
+10
-34
@@ -49,13 +49,6 @@ const escapesHelp = `Four characters in a path are escaped, so each row stays on
|
||||
\r a carriage return
|
||||
`
|
||||
|
||||
// operandsHelp is the paragraph of the report and trees help on their
|
||||
// PATH operands (README "Operands of `report` and `trees`").
|
||||
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.
|
||||
`
|
||||
|
||||
// reportHelp, treesHelp, infoHelp and dwimHelp follow the one-line
|
||||
// summary in the help of their subcommands.
|
||||
const (
|
||||
@@ -68,7 +61,7 @@ row per duplicate file. The columns are:
|
||||
|
||||
Rows are ordered by size, largest first, then by path.
|
||||
|
||||
` + escapesHelp + "\n" + operandsHelp
|
||||
` + escapesHelp
|
||||
|
||||
treesHelp = `The report is tab-separated text on stdout: a header line, then one
|
||||
row per duplicate directory tree. The columns are:
|
||||
@@ -81,7 +74,7 @@ row per duplicate directory tree. The columns are:
|
||||
|
||||
Rows are ordered by size, largest first, then by path.
|
||||
|
||||
` + escapesHelp + "\n" + operandsHelp
|
||||
` + escapesHelp
|
||||
|
||||
infoHelp = `The details go to stdout, one per line. Each line holds a name and its
|
||||
value, separated by a tab:
|
||||
@@ -115,11 +108,6 @@ var errWorkersBelowOne = errors.New("--workers must be at least 1")
|
||||
// would name the working directory.
|
||||
var errEmptyExcludeValue = errors.New("--exclude must not be empty")
|
||||
|
||||
// errEmptyOperand is the usage error for an empty PATH operand of
|
||||
// report or trees, as from "$DIR" with DIR unset. Taken as a path, it
|
||||
// would name the working directory.
|
||||
var errEmptyOperand = errors.New("PATH 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.
|
||||
@@ -241,20 +229,20 @@ func newRootCommand(stdout, stderr io.Writer) *cobra.Command {
|
||||
"print the version to stdout")
|
||||
|
||||
reportCmd := &cobra.Command{
|
||||
Use: cmdReport + " [PATH...]",
|
||||
Use: cmdReport,
|
||||
Short: "Read the scan database and print the file-level duplicates report",
|
||||
Args: rejectEmptyOperand,
|
||||
RunE: runE(func(ctx context.Context, args []string) error {
|
||||
return runReport(ctx, args, stdout)
|
||||
Args: cobra.NoArgs,
|
||||
RunE: runE(func(ctx context.Context, _ []string) error {
|
||||
return runReport(ctx, stdout)
|
||||
}),
|
||||
}
|
||||
|
||||
treesCmd := &cobra.Command{
|
||||
Use: cmdTrees + " [PATH...]",
|
||||
Use: cmdTrees,
|
||||
Short: "Read the scan database and print the duplicate-tree report",
|
||||
Args: rejectEmptyOperand,
|
||||
RunE: runE(func(ctx context.Context, args []string) error {
|
||||
return runTrees(ctx, args, stdout)
|
||||
Args: cobra.NoArgs,
|
||||
RunE: runE(func(ctx context.Context, _ []string) error {
|
||||
return runTrees(ctx, stdout)
|
||||
}),
|
||||
}
|
||||
|
||||
@@ -399,18 +387,6 @@ func rejectEmptyExcludeValue(cmd *cobra.Command, excludePaths []string) error {
|
||||
return errEmptyExcludeValue
|
||||
}
|
||||
|
||||
// rejectEmptyOperand rejects an empty PATH operand of report or trees.
|
||||
// That is a usage error reported in one line, as for --workers below 1.
|
||||
func rejectEmptyOperand(cmd *cobra.Command, args []string) error {
|
||||
if !slices.Contains(args, "") {
|
||||
return nil
|
||||
}
|
||||
|
||||
cmd.SilenceUsage = true
|
||||
|
||||
return errEmptyOperand
|
||||
}
|
||||
|
||||
// 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
|
||||
|
||||
@@ -583,14 +583,14 @@ func TestRunNamesDefaultDatabase(t *testing.T) {
|
||||
},
|
||||
cmdReport: {
|
||||
run: func() error {
|
||||
return runReport(cancelledContext(t), nil, io.Discard)
|
||||
return runReport(cancelledContext(t), io.Discard)
|
||||
},
|
||||
want: "report: database " + defaultDatabasePath + " (default)\n" +
|
||||
reportOpenLine + "\n" + reportOpenLine + "\n",
|
||||
},
|
||||
cmdTrees: {
|
||||
run: func() error {
|
||||
return runTrees(cancelledContext(t), nil, io.Discard)
|
||||
return runTrees(cancelledContext(t), io.Discard)
|
||||
},
|
||||
want: "trees: database " + defaultDatabasePath + " (default)\n" +
|
||||
treesOpenLine + "\n" + treesOpenLine + "\n",
|
||||
@@ -626,6 +626,8 @@ 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},
|
||||
@@ -762,16 +764,11 @@ func TestRunHelpDescribesDatabaseAndOutput(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// README §Settings: the help names the database, and says what
|
||||
// report, trees, info and dwim print. The help of report and trees
|
||||
// also explains their PATH operands.
|
||||
// report, trees, info and dwim print.
|
||||
database := []string{
|
||||
"scan and dwim store", databaseEnv, defaultDatabasePath, "needs root",
|
||||
}
|
||||
escapes := []string{`\\`, `\t`, `\n`, `\r`}
|
||||
operands := []string{
|
||||
"With PATH operands", "at or below them", "working directory",
|
||||
"No PATH is looked up", "not followed",
|
||||
}
|
||||
|
||||
// The subcommand whose help is printed; none for the root.
|
||||
cases := []struct {
|
||||
@@ -782,17 +779,17 @@ func TestRunHelpDescribesDatabaseAndOutput(t *testing.T) {
|
||||
{[]string{cmdScan}, database},
|
||||
{
|
||||
[]string{cmdReport},
|
||||
slices.Concat([]string{
|
||||
append([]string{
|
||||
"tab-separated", "\n first ", "\n dupe ", "\n size ",
|
||||
"largest first",
|
||||
}, escapes, operands),
|
||||
}, escapes...),
|
||||
},
|
||||
{
|
||||
[]string{cmdTrees},
|
||||
slices.Concat([]string{
|
||||
append([]string{
|
||||
"tab-separated", "\n first ", "\n dupe ", "\n files ",
|
||||
"\n size ", "\n disk_size ", "largest first",
|
||||
}, escapes, operands),
|
||||
}, escapes...),
|
||||
},
|
||||
{
|
||||
[]string{cmdInfo},
|
||||
@@ -1842,13 +1839,9 @@ func TestStdoutWriteErrorPropagates(t *testing.T) {
|
||||
scanFixture(t)
|
||||
|
||||
cases := map[string]func(context.Context, io.Writer) error{
|
||||
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,
|
||||
cmdReport: runReport,
|
||||
cmdTrees: runTrees,
|
||||
cmdInfo: runInfo,
|
||||
}
|
||||
|
||||
for name, fn := range cases {
|
||||
|
||||
@@ -26,7 +26,7 @@ func runDwim(
|
||||
return err
|
||||
}
|
||||
|
||||
err = runTrees(ctx, nil, stdout)
|
||||
err = runTrees(ctx, stdout)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
+14
-70
@@ -9,7 +9,6 @@ import (
|
||||
"io"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"syscall"
|
||||
@@ -45,12 +44,10 @@ func reportPhase(name string) string {
|
||||
}
|
||||
|
||||
// runReport implements the report subcommand: it prints the file-level
|
||||
// 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.
|
||||
// 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.
|
||||
//
|
||||
// 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
|
||||
@@ -58,12 +55,7 @@ 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, args []string, stdout io.Writer) error {
|
||||
operands, err := cleanOperands(args)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
func runReport(ctx context.Context, stdout io.Writer) error {
|
||||
dbPath, source, err := databasePath()
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -95,8 +87,7 @@ func runReport(ctx context.Context, args []string, stdout io.Writer) error {
|
||||
label: reportPhase("read"), unit: "records", total: -1,
|
||||
waitingFor: countingRecords, stalledOn: "db/disk/out",
|
||||
})
|
||||
report, err := readReport(ctx, db, dbPath, operands, stdout, pathExists,
|
||||
prog)
|
||||
report, err := readReport(ctx, db, dbPath, stdout, pathExists, prog)
|
||||
|
||||
prog.finish()
|
||||
|
||||
@@ -117,14 +108,12 @@ func runReport(ctx context.Context, args []string, 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. 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.
|
||||
// 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.
|
||||
func readReport(ctx context.Context, db *sql.DB, dbPath string,
|
||||
operands []string, stdout io.Writer, exists func(path string) bool,
|
||||
prog *progress,
|
||||
stdout io.Writer, exists func(path string) bool, prog *progress,
|
||||
) (*reportWriter, error) {
|
||||
out := prog.writer(stdout)
|
||||
report := &reportWriter{out: out, exists: exists}
|
||||
@@ -139,12 +128,6 @@ 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
|
||||
@@ -176,7 +159,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; readReport counts the records read.
|
||||
// reports.
|
||||
type reportWriter struct {
|
||||
out io.Writer
|
||||
|
||||
@@ -196,6 +179,8 @@ 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)
|
||||
@@ -288,47 +273,6 @@ 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. None is empty: rejectEmptyOperand refuses an
|
||||
// empty operand on the command line.
|
||||
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,8 +102,7 @@ func dupeGroups(t *testing.T, db *sql.DB) []dupeGroup {
|
||||
|
||||
var out bytes.Buffer
|
||||
|
||||
_, err := readReport(t.Context(), db, "", nil, &out, everyPathExists,
|
||||
nil)
|
||||
_, err := readReport(t.Context(), db, "", &out, everyPathExists, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -149,136 +148,6 @@ 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)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunReportsRejectEmptyOperand checks that an empty PATH operand of
|
||||
// report or trees, alone or after another operand, is a usage error
|
||||
// reported in one line before the database is opened (README "Error
|
||||
// handling and exit codes").
|
||||
func TestRunReportsRejectEmptyOperand(t *testing.T) {
|
||||
cases := map[string][]string{
|
||||
"report": {cmdReport, ""},
|
||||
"trees": {cmdTrees, ""},
|
||||
"after an operand": {cmdTrees, t.TempDir(), ""},
|
||||
}
|
||||
|
||||
for name, args := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
// No database exists there, so opening one would be a fatal
|
||||
// error, exit 1.
|
||||
t.Setenv(databaseEnv, testDBPath(t))
|
||||
|
||||
var stdout, stderr bytes.Buffer
|
||||
|
||||
code := run(args, &stdout, &stderr)
|
||||
if code != exitUsage {
|
||||
t.Errorf("run(%q) = %d, want %d", args, code, exitUsage)
|
||||
}
|
||||
|
||||
want := "Error: PATH must not be empty\n"
|
||||
if stdout.String() != "" || stderr.String() != want {
|
||||
t.Errorf("stdout, stderr = %q, %q, want \"\", %q",
|
||||
stdout.String(), stderr.String(), want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunReportEscapesPaths(t *testing.T) {
|
||||
dir, recs := recsOnDisk(t, awkwardPairRecs())
|
||||
t.Setenv(databaseEnv, seedDatabase(t, recs))
|
||||
@@ -326,7 +195,7 @@ func TestReportStdoutFailsWhileReading(t *testing.T) {
|
||||
// Counts the records read, and draws nothing.
|
||||
prog := &progress{now: time.Now}
|
||||
|
||||
_, err = readReport(t.Context(), db, "", nil, failingWriter{},
|
||||
_, err = readReport(t.Context(), db, "", failingWriter{},
|
||||
everyPathExists, prog)
|
||||
if !errors.Is(err, errWriteFailed) ||
|
||||
!strings.HasPrefix(err.Error(), "write stdout: ") {
|
||||
@@ -423,8 +292,7 @@ func TestReadReportOnTerminal(t *testing.T) {
|
||||
waitingFor: countingRecords,
|
||||
}, terminalWidth, time.Hour, time.Now)
|
||||
|
||||
_, err = readReport(t.Context(), db, "", nil, os.Stderr,
|
||||
everyPathExists, p)
|
||||
_, err = readReport(t.Context(), db, "", os.Stderr, everyPathExists, p)
|
||||
|
||||
p.finish()
|
||||
|
||||
@@ -646,7 +514,7 @@ func TestReadReportChecksOnlyPossibleDuplicates(t *testing.T) {
|
||||
return true
|
||||
}
|
||||
|
||||
_, err = readReport(t.Context(), db, "", nil, io.Discard, exists, nil)
|
||||
_, err = readReport(t.Context(), db, "", io.Discard, exists, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -680,8 +548,7 @@ func TestReadReportDropsGroupLeftWithOnePath(t *testing.T) {
|
||||
|
||||
exists := func(path string) bool { return path != "/a/gone" }
|
||||
|
||||
report, err := readReport(t.Context(), db, "", nil, io.Discard, exists,
|
||||
nil)
|
||||
report, err := readReport(t.Context(), db, "", io.Discard, exists, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -714,7 +581,7 @@ func TestReadReportKeepsGroupLeftWithTwoPaths(t *testing.T) {
|
||||
|
||||
var out bytes.Buffer
|
||||
|
||||
report, err := readReport(t.Context(), db, "", nil, &out, exists, nil)
|
||||
report, err := readReport(t.Context(), db, "", &out, exists, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
+56
-57
@@ -37,14 +37,12 @@ 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 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 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 work runs in four phases, each under a progress display of its
|
||||
// own on stderr: open (open the database), read (read the number of
|
||||
@@ -52,12 +50,7 @@ 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, args []string, stdout io.Writer) error {
|
||||
operands, err := cleanOperands(args)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
func runTrees(ctx context.Context, stdout io.Writer) error {
|
||||
dbPath, source, err := databasePath()
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -86,7 +79,7 @@ func runTrees(ctx context.Context, args []string, stdout io.Writer) error {
|
||||
label: treesPhase("read"), unit: "records", total: -1,
|
||||
waitingFor: countingRecords, stalledOn: "db",
|
||||
})
|
||||
records, super, allDirs, err := readTree(ctx, db, operands, prog)
|
||||
records, super, allDirs, err := readTree(ctx, db, prog)
|
||||
|
||||
prog.finish()
|
||||
|
||||
@@ -108,7 +101,7 @@ func runTrees(ctx context.Context, args []string, stdout io.Writer) error {
|
||||
label: treesPhase("write"), unit: "groups", total: int64(len(dupes)),
|
||||
stalledOn: "out",
|
||||
})
|
||||
dupeTrees, reclaimable, err := writeTreeGroups(stdout, dupes, prog)
|
||||
dupeTrees, err := writeTreeGroups(stdout, dupes, prog)
|
||||
|
||||
prog.finish()
|
||||
|
||||
@@ -119,23 +112,16 @@ func runTrees(ctx context.Context, args []string, stdout io.Writer) error {
|
||||
fmt.Fprintf(os.Stderr,
|
||||
"trees: %d records read, %d duplicate tree groups, %d dupe trees, "+
|
||||
"%s reclaimable\n",
|
||||
records, len(dupes), dupeTrees, humanBytes(reclaimable))
|
||||
records, len(dupes), dupeTrees, humanBytes(reclaimableBytes(dupes)))
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// readTree gives prog the number of records in db as its total, then
|
||||
// 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,
|
||||
// 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,
|
||||
prog *progress,
|
||||
) (int, *treeNode, []*treeNode, error) {
|
||||
records := 0
|
||||
@@ -145,10 +131,7 @@ func readTree(ctx context.Context, db *sql.DB, operands []string,
|
||||
records++
|
||||
|
||||
prog.increment()
|
||||
|
||||
if underOperand(r.path, operands) {
|
||||
tree.add(r)
|
||||
}
|
||||
tree.add(r)
|
||||
})
|
||||
if err != nil {
|
||||
return 0, nil, nil, err
|
||||
@@ -156,43 +139,26 @@ func readTree(ctx context.Context, db *sql.DB, operands []string,
|
||||
|
||||
super, allDirs := tree.finish()
|
||||
|
||||
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
|
||||
return records, super, allDirs, nil
|
||||
}
|
||||
|
||||
// writeTreeGroups writes dupes to stdout as TSV, a header line and then
|
||||
// a row for every member of each group but its first, counting each
|
||||
// group on prog once its rows are written. The disk_size column is the
|
||||
// dupe's own. stdout may be the terminal prog is drawn on, so the lines
|
||||
// go through prog's writer. It returns the number of rows (dupe trees)
|
||||
// and the bytes they could reclaim.
|
||||
// go through prog's writer. It returns the number of rows (dupe trees).
|
||||
func writeTreeGroups(stdout io.Writer, dupes [][]*treeNode,
|
||||
prog *progress,
|
||||
) (int, int64, error) {
|
||||
) (int, error) {
|
||||
out := prog.writer(stdout)
|
||||
|
||||
_, err := fmt.Fprintln(out, "first\tdupe\tfiles\tsize\tdisk_size")
|
||||
if err != nil {
|
||||
return 0, 0, fmt.Errorf("write stdout: %w", err)
|
||||
return 0, fmt.Errorf("write stdout: %w", err)
|
||||
}
|
||||
|
||||
dupeTrees := 0
|
||||
|
||||
var reclaimable int64
|
||||
|
||||
for _, g := range dupes {
|
||||
first := g[0]
|
||||
for _, n := range g[1:] {
|
||||
@@ -200,11 +166,10 @@ func writeTreeGroups(stdout io.Writer, dupes [][]*treeNode,
|
||||
escapePath(first.path), escapePath(n.path),
|
||||
first.fileCount, first.totalSize, n.diskSize)
|
||||
if err != nil {
|
||||
return 0, 0, fmt.Errorf("write stdout: %w", err)
|
||||
return 0, fmt.Errorf("write stdout: %w", err)
|
||||
}
|
||||
|
||||
dupeTrees++
|
||||
reclaimable += first.totalSize
|
||||
}
|
||||
|
||||
prog.increment()
|
||||
@@ -212,10 +177,44 @@ func writeTreeGroups(stdout io.Writer, dupes [][]*treeNode,
|
||||
|
||||
err = out.Flush()
|
||||
if err != nil {
|
||||
return 0, 0, fmt.Errorf("write stdout: %w", err)
|
||||
return 0, fmt.Errorf("write stdout: %w", err)
|
||||
}
|
||||
|
||||
return dupeTrees, reclaimable, nil
|
||||
return dupeTrees, nil
|
||||
}
|
||||
|
||||
// reclaimableBytes returns the sum of the size column over the rows
|
||||
// that writeTreeGroups writes for dupes, leaving out a row whose dupe
|
||||
// lies inside another row's dupe.
|
||||
func reclaimableBytes(dupes [][]*treeNode) int64 {
|
||||
isDupe := make(map[*treeNode]bool)
|
||||
|
||||
for _, g := range dupes {
|
||||
for _, n := range g[1:] {
|
||||
isDupe[n] = true
|
||||
}
|
||||
}
|
||||
|
||||
var total int64
|
||||
|
||||
for n := range isDupe {
|
||||
if !insideDupe(n, isDupe) {
|
||||
total += n.totalSize
|
||||
}
|
||||
}
|
||||
|
||||
return total
|
||||
}
|
||||
|
||||
// insideDupe reports whether a directory above n is in isDupe.
|
||||
func insideDupe(n *treeNode, isDupe map[*treeNode]bool) bool {
|
||||
for p := n.parent; p != nil; p = p.parent {
|
||||
if isDupe[p] {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// treeBuilder reconstructs the directory hierarchy from records added
|
||||
|
||||
@@ -214,57 +214,6 @@ 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.
|
||||
@@ -364,7 +313,7 @@ func TestWriteTreeGroupsOnTerminal(t *testing.T) {
|
||||
label: treesPhase("write"), unit: "groups", total: int64(len(dupes)),
|
||||
}, terminalWidth, time.Hour, time.Now)
|
||||
|
||||
_, _, err := writeTreeGroups(os.Stderr, dupes, p)
|
||||
_, err := writeTreeGroups(os.Stderr, dupes, p)
|
||||
|
||||
p.finish()
|
||||
|
||||
@@ -638,3 +587,64 @@ func TestCollectTreeGroupsKeepsGroupLeftWithTwoCopies(t *testing.T) {
|
||||
t.Errorf("groups = %v, want %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// TestReclaimableBytesCountsNestedDupeOnce checks that a dupe tree
|
||||
// inside another dupe tree adds nothing to the reclaimable bytes. /B/x
|
||||
// lies in /B, so the total adds the sizes of /B and /C/x, 1500 + 1000.
|
||||
func TestReclaimableBytesCountsNestedDupeOnce(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
fh, ft, fc := testHash("fh"), testHash("ft"), testHash("fc")
|
||||
gh, gt, gc := testHash("gh"), testHash("gt"), testHash("gc")
|
||||
recs := []scanRec{
|
||||
{size: 1000, head: fh, tail: ft, content: fc, path: "/A/x/f"},
|
||||
{size: 500, head: gh, tail: gt, content: gc, path: "/A/y/g"},
|
||||
{size: 1000, head: fh, tail: ft, content: fc, path: "/B/x/f"},
|
||||
{size: 500, head: gh, tail: gt, content: gc, path: "/B/y/g"},
|
||||
{size: 1000, head: fh, tail: ft, content: fc, path: "/C/x/f"},
|
||||
}
|
||||
|
||||
super, dirs := treeOf(t, recs)
|
||||
dupes := collectTreeGroups(dirs, super, everyPathExists, nil)
|
||||
|
||||
wantGroups := [][]string{{"/A", "/B"}, {"/A/x", "/B/x", "/C/x"}}
|
||||
if got := groupPaths(dupes); !slices.EqualFunc(got, wantGroups,
|
||||
slices.Equal) {
|
||||
t.Fatalf("groups = %v, want %v", got, wantGroups)
|
||||
}
|
||||
|
||||
if got := reclaimableBytes(dupes); got != 2500 {
|
||||
t.Errorf("reclaimableBytes = %d, want 2500", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestReclaimableBytesCountsDupeInsideGrandparentDupeOnce checks that a
|
||||
// dupe tree adds nothing when a dupe tree above its parent holds it.
|
||||
// /B/m/x lies in /B, and /B/m is no dupe, since the group of /A and /B
|
||||
// implies that of /A/m and /B/m. The total adds the sizes of /B and
|
||||
// /C/x, 1300 + 1000.
|
||||
func TestReclaimableBytesCountsDupeInsideGrandparentDupeOnce(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
f, w := testHash("f"), testHash("w")
|
||||
recs := []scanRec{
|
||||
{size: 1000, head: f, tail: f, content: f, path: "/A/m/x/f"},
|
||||
{size: 300, head: w, tail: w, content: w, path: "/A/m/w"},
|
||||
{size: 1000, head: f, tail: f, content: f, path: "/B/m/x/f"},
|
||||
{size: 300, head: w, tail: w, content: w, path: "/B/m/w"},
|
||||
{size: 1000, head: f, tail: f, content: f, path: "/C/x/f"},
|
||||
}
|
||||
|
||||
super, dirs := treeOf(t, recs)
|
||||
dupes := collectTreeGroups(dirs, super, everyPathExists, nil)
|
||||
|
||||
wantGroups := [][]string{{"/A", "/B"}, {"/A/m/x", "/B/m/x", "/C/x"}}
|
||||
if got := groupPaths(dupes); !slices.EqualFunc(got, wantGroups,
|
||||
slices.Equal) {
|
||||
t.Fatalf("groups = %v, want %v", got, wantGroups)
|
||||
}
|
||||
|
||||
if got := reclaimableBytes(dupes); got != 2300 {
|
||||
t.Errorf("reclaimableBytes = %d, want 2300", got)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user