clawbot
f7a746f912
check / check (push) Canceled after 0s
Every file the walk records now gets three hashes: head and tail, of its first and last 64 KiB, and content. The content hash covers the whole file under 100 MiB, and 1 MiB at each gigabyte from 100 MiB up, so a large file is never read in full. One 100 MiB constant replaces the 10 MiB and 50 MiB thresholds. The size census, the records stored without hashes and the content phase are gone, so a rescan reads only new and changed files. report and trees no longer special-case a missing content hash. README "Duplicate detection" and "Rationale" are rewritten. Judgement call: info drops its two hash-count lines, which now always equal the record count. Model: opus-5-5
126 lines
3.6 KiB
Go
126 lines
3.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// infoPhase names one phase of info with its place among all of them,
|
|
// as "[2/2] count", for the phase's progress display. The list here is
|
|
// the one place the phases are counted.
|
|
func infoPhase(name string) string {
|
|
return phaseLabel([]string{openPhase, "count"}, name)
|
|
}
|
|
|
|
// runInfo implements the info subcommand: it prints the database's
|
|
// details on stdout (see writeInfo). It opens the database as report
|
|
// does, read-only and without the scan lock, and never touches the
|
|
// scanned filesystem. 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 count (count the records,
|
|
// with one query). Each display ends before the next phase starts, and
|
|
// before an error is returned to be printed. The details are written
|
|
// once the last display has ended, so no display is drawn while they
|
|
// are written.
|
|
func runInfo(ctx context.Context, stdout io.Writer) error {
|
|
dbPath, source, err := databasePath()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Fprintf(os.Stderr, "info: database %s (%s)\n",
|
|
escapePath(dbPath), source)
|
|
|
|
// Opening can wait on a busy database for as long as the busy
|
|
// timeout.
|
|
prog := newProgress(progressParams{
|
|
label: infoPhase(openPhase), total: -1,
|
|
waitingFor: openingDatabase,
|
|
})
|
|
db, err := openReportDatabase(ctx, dbPath)
|
|
|
|
prog.finish()
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
defer func() { _ = db.Close() }()
|
|
|
|
// One query counts everything, so the phase never has a total.
|
|
prog = newProgress(progressParams{
|
|
label: infoPhase("count"), total: -1,
|
|
waitingFor: countingRecords,
|
|
})
|
|
counts, err := readDatabaseCounts(ctx, db)
|
|
|
|
prog.finish()
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("database %s: %w", dbPath, err)
|
|
}
|
|
|
|
return writeInfo(stdout, dbPath, source, counts)
|
|
}
|
|
|
|
// writeInfo writes the details of the database at dbPath to stdout,
|
|
// one per line, as a name, a tab and the value (README "`info` mode"):
|
|
// the path and source as databasePath returns them, the sizes of the
|
|
// database file and of its -wal file when there is one, when the
|
|
// database file was last changed, and the schema version and record
|
|
// counts that readDatabaseCounts read.
|
|
func writeInfo(stdout io.Writer, dbPath, source string,
|
|
counts databaseCounts,
|
|
) error {
|
|
// SQLite keeps the -wal file beside the database file, named from
|
|
// its path with symlinks resolved.
|
|
file, err := filepath.EvalSymlinks(dbPath)
|
|
if err != nil {
|
|
return fmt.Errorf("database: %w", err)
|
|
}
|
|
|
|
dbFile, err := os.Stat(file)
|
|
if err != nil {
|
|
return fmt.Errorf("database: %w", err)
|
|
}
|
|
|
|
walFile, err := os.Stat(file + "-wal")
|
|
if err != nil && !errors.Is(err, fs.ErrNotExist) {
|
|
return fmt.Errorf("database: %w", err)
|
|
}
|
|
|
|
var b strings.Builder
|
|
|
|
fmt.Fprintf(&b, "database\t%s (%s)\n", escapePath(dbPath), source)
|
|
fmt.Fprintf(&b, "database file size\t%d (%s)\n",
|
|
dbFile.Size(), humanBytes(dbFile.Size()))
|
|
|
|
if walFile != nil {
|
|
fmt.Fprintf(&b, "-wal file size\t%d (%s)\n",
|
|
walFile.Size(), humanBytes(walFile.Size()))
|
|
}
|
|
|
|
fmt.Fprintf(&b, "modified\t%s\n",
|
|
dbFile.ModTime().UTC().Format(time.RFC3339))
|
|
fmt.Fprintf(&b, "schema version\t%d\n", counts.schemaVersion)
|
|
fmt.Fprintf(&b, "records\t%d\n", counts.records)
|
|
fmt.Fprintf(&b, "size of recorded files\t%d (%s)\n",
|
|
counts.size, humanBytes(counts.size))
|
|
|
|
_, err = io.WriteString(stdout, b.String())
|
|
if err != nil {
|
|
return fmt.Errorf("write stdout: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|