From 06faf0877cc105e64cd0c966896f8249cf21edbc Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Thu, 19 Nov 2026 22:13:55 +0100 Subject: [PATCH] dirwatch: one loop that watches a directory, for rules and lookup (closes #429) rules and lookup each had the same loop: watch the directory, start a timer at once, restart it at each change that counts, read again when it fires. It now lives once in internal/dirwatch, with its quiet time and its tests. Each package keeps its own log messages, its readAgain, and its test for which changes count. internal/state keeps its own copy. Model: opus-5-5 --- README.md | 2 + SPEC.md | 3 + internal/dirwatch/dirwatch.go | 90 ++++++++++ internal/dirwatch/dirwatch_internal_test.go | 167 +++++++++++++++++++ internal/lookup/file.go | 67 ++------ internal/lookup/file_internal_test.go | 176 ++++---------------- internal/rules/rules.go | 67 +++----- internal/rules/watch_internal_test.go | 165 ------------------ 8 files changed, 334 insertions(+), 403 deletions(-) create mode 100644 internal/dirwatch/dirwatch.go create mode 100644 internal/dirwatch/dirwatch_internal_test.go delete mode 100644 internal/rules/watch_internal_test.go diff --git a/README.md b/README.md index 56fb88b..b835147 100644 --- a/README.md +++ b/README.md @@ -906,6 +906,8 @@ stops the running process (see [`docs/state-files.md`](docs/state-files.md)). `internal/coreruleset`, `internal/geojs`, `internal/lookup`, `internal/reputation`, `internal/routewatch`, `internal/anomaly` and `internal/alerts`: one check or source each. +- `internal/dirwatch`: watches a directory, so that `internal/rules` and + `internal/lookup` read their files again when they change. - `internal/state`: the state and cache files. - `internal/requestlog`: the request log. - `internal/processlog`: the process's own messages. diff --git a/SPEC.md b/SPEC.md index d0c4620..3c8b4da 100644 --- a/SPEC.md +++ b/SPEC.md @@ -94,6 +94,9 @@ never as a time. imports no other package of this repository: `waf` gives it what it needs to count and report failures. - `internal/lookup`: looks clients up in the lookup database. + - `internal/dirwatch`: watches a directory, and calls a function once it has + gone a short time without a change. `internal/rules` and `internal/lookup` + read their files again this way. - `internal/reputation`: fetches the lists, asks the DNS blocklists and AbuseIPDB in the background, and keeps their answers. It also fetches AbuseIPDB's blacklist, which `internal/waf` bans. diff --git a/internal/dirwatch/dirwatch.go b/internal/dirwatch/dirwatch.go new file mode 100644 index 0000000..1344e60 --- /dev/null +++ b/internal/dirwatch/dirwatch.go @@ -0,0 +1,90 @@ +// Package dirwatch watches a directory, and calls a function once the +// directory has gone a short time without a change after one. The rule +// files and the lookup database are read again this way. +package dirwatch + +import ( + "context" + "time" + + "github.com/fsnotify/fsnotify" +) + +// quietTime is how long the directory must go without a change before the +// function is called, so that a file still being written, such as one +// saved in place, appended to or copied in with scp, is read only once +// whole. +const quietTime = 2 * time.Second + +// Watcher watches one directory. The directory is watched, rather than a +// file in it, so that a file replaced by a rename is seen. +type Watcher struct { + watcher *fsnotify.Watcher +} + +// New starts watching dir, or returns why it cannot. +func New(dir string) (*Watcher, error) { + watcher, err := fsnotify.NewWatcher() + if err != nil { + return nil, err + } + + err = watcher.Add(dir) + if err != nil { + _ = watcher.Close() + + return nil, err + } + + return &Watcher{watcher: watcher}, nil +} + +// Close stops watching the directory. +func (w *Watcher) Close() error { + return w.watcher.Close() +} + +// CallWhenQuiet calls changed each time the directory has gone quietTime +// without a change, after a change to a path for which counts is true, until +// ctx is done. It also calls failed with each error the watch reports. The +// wait starts at once, as if for a change, so that a change made before the +// watch began is taken in too. +func (w *Watcher) CallWhenQuiet( + ctx context.Context, + counts func(path string) bool, + changed func(), + failed func(error), +) { + callWhenQuiet( + ctx, w.watcher.Events, w.watcher.Errors, counts, changed, failed, + ) +} + +// callWhenQuiet is CallWhenQuiet, for the changes from events and the +// errors from errs. +func callWhenQuiet( + ctx context.Context, + events <-chan fsnotify.Event, + errs <-chan error, + counts func(path string) bool, + changed func(), + failed func(error), +) { + quiet := time.NewTimer(quietTime) + defer quiet.Stop() + + for { + select { + case <-ctx.Done(): + return + case event := <-events: + if counts(event.Name) { + quiet.Reset(quietTime) + } + case <-quiet.C: + changed() + case err := <-errs: + failed(err) + } + } +} diff --git a/internal/dirwatch/dirwatch_internal_test.go b/internal/dirwatch/dirwatch_internal_test.go new file mode 100644 index 0000000..bd0d8c1 --- /dev/null +++ b/internal/dirwatch/dirwatch_internal_test.go @@ -0,0 +1,167 @@ +package dirwatch + +import ( + "context" + "errors" + "path/filepath" + "sync/atomic" + "testing" + "testing/synctest" + "time" + + "github.com/fsnotify/fsnotify" +) + +// errWatch is an error the watch reports. +var errWatch = errors.New("too many changes") + +func TestDirectoryThatCannotBeWatchedIsAnError(t *testing.T) { + t.Parallel() + + _, err := New(filepath.Join(t.TempDir(), "missing")) + if err == nil { + t.Error("a missing directory is watched, want an error") + } +} + +// The tests below run callWhenQuiet in a synctest bubble, where time is a +// clock of the test's own: time.Sleep moves it on at once, and +// synctest.Wait returns once callWhenQuiet waits again, so that every call +// due by then is made. The test sends the changes itself, as the watch of +// a directory cannot run in a bubble. + +func TestSecondChangeStartsTheWaitAgain(t *testing.T) { + t.Parallel() + + synctest.Test(t, func(t *testing.T) { + loop := start(t, everyPath) + + loop.changes <- fsnotify.Event{Name: "50-app.rules", Op: fsnotify.Write} + + time.Sleep(quietTime - time.Nanosecond) + synctest.Wait() + loop.wantCalls(t, 0) + + // The second part starts the wait again. + loop.changes <- fsnotify.Event{Name: "50-app.rules", Op: fsnotify.Write} + + time.Sleep(quietTime - time.Nanosecond) + synctest.Wait() + loop.wantCalls(t, 0) + + time.Sleep(time.Nanosecond) + synctest.Wait() + loop.wantCalls(t, 1) + }) +} + +func TestCalledOnceQuietAfterTheStart(t *testing.T) { + t.Parallel() + + synctest.Test(t, func(t *testing.T) { + // An edit saved before the watch began sends no change, and is + // taken in by this call. + loop := start(t, everyPath) + + time.Sleep(quietTime) + synctest.Wait() + loop.wantCalls(t, 1) + + // Long after, it has been called only once. + time.Sleep(time.Hour) + synctest.Wait() + loop.wantCalls(t, 1) + }) +} + +func TestChangeThatDoesNotCountIsNoChange(t *testing.T) { + t.Parallel() + + synctest.Test(t, func(t *testing.T) { + loop := start(t, func(path string) bool { + return path == "ipinfo_lite.mmdb" + }) + + // The wait that starts with the watch ends with a call. + time.Sleep(quietTime) + synctest.Wait() + + loop.changes <- fsnotify.Event{Name: "other.mmdb", Op: fsnotify.Create} + + time.Sleep(quietTime) + synctest.Wait() + loop.wantCalls(t, 1) + + loop.changes <- fsnotify.Event{Name: "ipinfo_lite.mmdb", Op: fsnotify.Write} + + time.Sleep(quietTime) + synctest.Wait() + loop.wantCalls(t, 2) + }) +} + +func TestErrorsOfTheWatchHandedOn(t *testing.T) { + t.Parallel() + + synctest.Test(t, func(t *testing.T) { + loop := start(t, everyPath) + + loop.errs <- errWatch + + synctest.Wait() + + if !errors.Is(loop.failure, errWatch) { + t.Errorf("failed with %v, want %v", loop.failure, errWatch) + } + }) +} + +// loop is a callWhenQuiet that a test runs. +type loop struct { + // changes and errs send it changes and errors. + changes chan fsnotify.Event + errs chan error + // calls counts its calls of changed, and failure is the last error it + // handed to failed. + calls atomic.Int32 + failure error +} + +// start runs callWhenQuiet, with counts, until the test ends. +func start(t *testing.T, counts func(path string) bool) *loop { + t.Helper() + + l := &loop{changes: make(chan fsnotify.Event), errs: make(chan error)} + ctx, stop := context.WithCancel(t.Context()) + stopped := make(chan struct{}) + + go func() { + callWhenQuiet(ctx, l.changes, l.errs, counts, + func() { l.calls.Add(1) }, + func(err error) { l.failure = err }, + ) + close(stopped) + }() + + t.Cleanup(func() { + stop() + <-stopped + }) + + return l +} + +// everyPath counts a change to any path. +func everyPath(string) bool { + return true +} + +// wantCalls checks how many times changed has been called. +func (l *loop) wantCalls(t *testing.T, want int32) { + t.Helper() + + got := l.calls.Load() + if got != want { + t.Errorf("changed called %d times, want %d", got, want) + } +} diff --git a/internal/lookup/file.go b/internal/lookup/file.go index 1c028f5..2da7d9a 100644 --- a/internal/lookup/file.go +++ b/internal/lookup/file.go @@ -13,18 +13,13 @@ import ( "sync" "time" - "github.com/fsnotify/fsnotify" "github.com/oschwald/maxminddb-golang/v2" "sneak.berlin/go/smallwebwaf/internal/alerts" + "sneak.berlin/go/smallwebwaf/internal/dirwatch" "sneak.berlin/go/smallwebwaf/internal/geojs" ) -// quietTime is how long the lookup database must go without a change -// before it is read again, so that a file still being copied in is read -// only once whole. -const quietTime = 2 * time.Second - // FileParams are what OpenFile needs. type FileParams struct { // Path is the lookup database, the IPinfo Lite file in its .mmdb form @@ -122,20 +117,13 @@ func (f *File) ReadFailures() int { } // Watch watches the directory of the lookup database until ctx is done, -// and reads the file again once it has gone without a change for -// quietTime, after it is replaced, written or removed, and after Watch -// starts watching. If the directory cannot be watched, that is logged, and -// the database read at start stays in use. +// and reads the file again once it has gone without a change for a short +// time, after it is replaced, written or removed, and after Watch starts +// watching, as dirwatch describes. A change to another file in its +// directory does not count. If the directory cannot be watched, that is +// logged, and the database read at start stays in use. func (f *File) Watch(ctx context.Context) { - watcher, err := fsnotify.NewWatcher() - if err == nil { - defer func() { - _ = watcher.Close() - }() - - err = watcher.Add(filepath.Dir(f.params.Path)) - } - + watcher, err := dirwatch.New(filepath.Dir(f.params.Path)) if err != nil { f.params.ProcessLog.Error( "cannot watch the lookup database for replacements", @@ -146,41 +134,22 @@ func (f *File) Watch(ctx context.Context) { return } + defer func() { + _ = watcher.Close() + }() + f.params.ProcessLog.Info("watching the lookup database for replacements", "file", f.params.Path) - f.readAfterChanges(ctx, watcher.Events, watcher.Errors) + watcher.CallWhenQuiet(ctx, f.isDatabase, f.readAgain, func(err error) { + f.params.ProcessLog.Warn("watching the lookup database failed", + "error", err.Error()) + }) } -// readAfterChanges reads the lookup database again once quietTime has -// passed without a change to it from events, until ctx is done, and logs -// the errors from errs. A change to another file in its directory does not -// count. The wait starts at once, as if for a change, so that a file -// replaced after OpenFile read it, and before its directory was watched, -// is read too. -func (f *File) readAfterChanges( - ctx context.Context, events <-chan fsnotify.Event, errs <-chan error, -) { - path := filepath.Clean(f.params.Path) - - quiet := time.NewTimer(quietTime) - defer quiet.Stop() - - for { - select { - case <-ctx.Done(): - return - case event := <-events: - if filepath.Clean(event.Name) == path { - quiet.Reset(quietTime) - } - case <-quiet.C: - f.readAgain() - case err := <-errs: - f.params.ProcessLog.Warn("watching the lookup database failed", - "error", err.Error()) - } - } +// isDatabase reports whether path names the lookup database. +func (f *File) isDatabase(path string) bool { + return filepath.Clean(path) == filepath.Clean(f.params.Path) } // readAgain reads the lookup database again, in place of the one in use, diff --git a/internal/lookup/file_internal_test.go b/internal/lookup/file_internal_test.go index a49c68b..f38fdcd 100644 --- a/internal/lookup/file_internal_test.go +++ b/internal/lookup/file_internal_test.go @@ -1,7 +1,6 @@ package lookup import ( - "context" "log/slog" "net/netip" "net/url" @@ -12,7 +11,6 @@ import ( "testing/synctest" "time" - "github.com/fsnotify/fsnotify" "github.com/maxmind/mmdbwriter/mmdbtype" "sneak.berlin/go/smallwebwaf/internal/alerts" @@ -133,66 +131,48 @@ func TestFileThatCannotBeReadIsAnError(t *testing.T) { } } -// The tests below run readAfterChanges in a synctest bubble, where time is -// a clock of the test's own: time.Sleep moves it on at once, and -// synctest.Wait returns once readAfterChanges waits again, so that every -// reading due by then is done. The test sends the changes itself, as the -// watch of a directory cannot run in a bubble. +func TestChangeOfAnotherFileInTheDirectoryIsNoReplacement(t *testing.T) { + t.Parallel() -func TestReplacementCopiedOverTheFileInTwoPartsIsReadOnlyWhole( - t *testing.T, -) { + dir := t.TempDir() + path := filepath.Join(dir, "ipinfo_lite.mmdb") + writeDatabase(t, path, "DE") + + f := openFile(t, path, newQueue()) + + for changed, want := range map[string]bool{ + path: true, + dir + "/./ipinfo_lite.mmdb": true, + filepath.Join(dir, "other.mmdb"): false, + } { + if f.isDatabase(changed) != want { + t.Errorf( + "a change to %s counts: %t, want %t", + changed, + !want, + want, + ) + } + } +} + +// The tests below run in a synctest bubble, where time is a clock of the +// test's own, so that the time a file is read can be checked. The wait for +// the directory to go quiet before a reading is tested in dirwatch. + +func TestReplacementIsReadAgain(t *testing.T) { t.Parallel() synctest.Test(t, func(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "ipinfo_lite.mmdb") + path := filepath.Join(t.TempDir(), "ipinfo_lite.mmdb") writeDatabase(t, path, "DE") queue := newQueue() f := openFile(t, path, queue) - changes := watch(t, f) - other := filepath.Join(dir, "replacement.mmdb") - writeDatabase(t, other, "KP") - - //nolint:gosec // a file the test wrote - replacement, err := os.ReadFile(other) - if err != nil { - t.Fatalf("read %s: %v", other, err) - } - - // The file in use is overwritten in place, and keeps giving what - // it gave. Its first part alone is not a .mmdb file. - file, err := os.Create(path) //nolint:gosec // a file the test wrote - if err != nil { - t.Fatalf("create %s: %v", path, err) - } - - defer func() { - _ = file.Close() - }() - - half := len(replacement) / 2 - write(t, file, replacement[:half]) - - changes <- fsnotify.Event{Name: path, Op: fsnotify.Write} - - time.Sleep(quietTime - time.Nanosecond) - synctest.Wait() - wantCountry(t, f, "DE") - - // The second part starts the wait again. - write(t, file, replacement[half:]) - - changes <- fsnotify.Event{Name: path, Op: fsnotify.Write} - - time.Sleep(quietTime - time.Nanosecond) - synctest.Wait() - wantCountry(t, f, "DE") - - time.Sleep(time.Nanosecond) - synctest.Wait() + writeDatabase(t, path, "KP") + time.Sleep(time.Hour) + f.readAgain() wantCountry(t, f, "KP") if !f.LastRead().Equal(time.Now()) || f.ReadFailures() != 0 { @@ -219,15 +199,10 @@ func TestReplacementThatCannotBeReadLeavesTheFileInUseWithOneAlert( queue := newQueue() f := openFile(t, path, queue) read := f.LastRead() - changes := watch(t, f) writeFile(t, path, "not a lookup database\n") - - changes <- fsnotify.Event{Name: path, Op: fsnotify.Write} - - // Long after, the replacement has been read once. time.Sleep(time.Hour) - synctest.Wait() + f.readAgain() wantCountry(t, f, "DE") if !f.LastRead().Equal(read) || f.ReadFailures() != 1 { @@ -240,7 +215,7 @@ func TestReplacementThatCannotBeReadLeavesTheFileInUseWithOneAlert( } wantAlerts(t, queue, alerts.Alert{ - Time: read.Add(quietTime), + Time: read.Add(time.Hour), Event: alerts.EventFileError, Reason: "the lookup database cannot be read, and the one read before stays in use", Detail: map[string]any{ @@ -252,55 +227,6 @@ func TestReplacementThatCannotBeReadLeavesTheFileInUseWithOneAlert( }) } -func TestChangeOfAnotherFileInTheDirectoryIsNoReplacement(t *testing.T) { - t.Parallel() - - synctest.Test(t, func(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "ipinfo_lite.mmdb") - writeDatabase(t, path, "DE") - - f := openFile(t, path, newQueue()) - changes := watch(t, f) - - // The wait that starts with the watch ends with a reading. - time.Sleep(quietTime) - synctest.Wait() - writeDatabase(t, path, "KP") - - changes <- fsnotify.Event{Name: filepath.Join(dir, "other.mmdb"), Op: fsnotify.Create} - - time.Sleep(quietTime) - synctest.Wait() - wantCountry(t, f, "DE") - - changes <- fsnotify.Event{Name: path, Op: fsnotify.Write} - - time.Sleep(quietTime) - synctest.Wait() - wantCountry(t, f, "KP") - }) -} - -func TestReplacementSavedBeforeTheWatchStartsIsRead(t *testing.T) { - t.Parallel() - - synctest.Test(t, func(t *testing.T) { - path := filepath.Join(t.TempDir(), "ipinfo_lite.mmdb") - writeDatabase(t, path, "DE") - - f := openFile(t, path, newQueue()) - - // Saved after OpenFile read the file, and before its directory was - // watched, so that no change is seen for it. - writeDatabase(t, path, "KP") - watch(t, f) - time.Sleep(quietTime) - synctest.Wait() - wantCountry(t, f, "KP") - }) -} - // newQueue returns a queue of alerts for a webhook that is never sent // them, so that they wait in it for the test to look at. func newQueue() *alerts.Queue { @@ -344,28 +270,6 @@ func openFile(t *testing.T, path string, queue *alerts.Queue) *File { return f } -// watch runs f's readAfterChanges until the test ends, and returns the -// channel that sends it changes. -func watch(t *testing.T, f *File) chan<- fsnotify.Event { - t.Helper() - - changes := make(chan fsnotify.Event) - ctx, stop := context.WithCancel(t.Context()) - stopped := make(chan struct{}) - - go func() { - f.readAfterChanges(ctx, changes, nil) - close(stopped) - }() - - t.Cleanup(func() { - stop() - <-stopped - }) - - return changes -} - // wantCountry checks the country f gives testClient. func wantCountry(t *testing.T, f *File, want string) { t.Helper() @@ -401,13 +305,3 @@ func writeFile(t *testing.T, path, content string) { t.Fatalf("write %s: %v", path, err) } } - -// write writes data to the end of file. -func write(t *testing.T, file *os.File, data []byte) { - t.Helper() - - _, err := file.Write(data) - if err != nil { - t.Fatalf("write: %v", err) - } -} diff --git a/internal/rules/rules.go b/internal/rules/rules.go index ac9bbd1..4da2df8 100644 --- a/internal/rules/rules.go +++ b/internal/rules/rules.go @@ -18,12 +18,11 @@ import ( "slices" "strings" "sync/atomic" - "time" - "github.com/fsnotify/fsnotify" "golang.org/x/net/http/httpguts" "sneak.berlin/go/smallwebwaf/internal/alerts" + "sneak.berlin/go/smallwebwaf/internal/dirwatch" ) // The actions a rule takes when it matches. @@ -40,12 +39,6 @@ const ( // extension ends the name of every rule file. const extension = ".rules" -// quietTime is how long SWW_WAF_RULE_FILES_DIR must go without a change before -// the rule files are read again, so that a file still being written, such -// as one saved in place, appended to or copied in with scp, is read only -// once whole. -const quietTime = 2 * time.Second - // headerTarget starts the target that is one request header, // header:. const headerTarget = "header:" @@ -176,26 +169,18 @@ func (f *Files) Len() int { } // Watch watches Dir until ctx is done, and reads the rule files again -// once Dir has had no change for quietTime, after one is edited, added or -// removed, and after Watch starts watching. If they then hold an error, -// the rules stay as they were, the error is logged with its file and -// line, and the files are read again after the next change. If Dir cannot -// be watched, that is logged, and the rules stay as they were loaded. -// While Enabled is false, Watch returns at once. +// once Dir has had no change for a short time, after one is edited, added +// or removed, and after Watch starts watching, as dirwatch describes. If +// they then hold an error, the rules stay as they were, the error is +// logged with its file and line, and the files are read again after the +// next change. If Dir cannot be watched, that is logged, and the rules +// stay as they were loaded. While Enabled is false, Watch returns at once. func (f *Files) Watch(ctx context.Context) { if !f.params.Enabled { return } - watcher, err := fsnotify.NewWatcher() - if err == nil { - defer func() { - _ = watcher.Close() - }() - - err = watcher.Add(f.params.Dir) - } - + watcher, err := dirwatch.New(f.params.Dir) if err != nil { f.params.ProcessLog.Error("cannot watch the rule files for edits", "error", err.Error()) @@ -203,36 +188,22 @@ func (f *Files) Watch(ctx context.Context) { return } + defer func() { + _ = watcher.Close() + }() + f.params.ProcessLog.Info("watching the rule files for edits", "directory", f.params.Dir) - f.readAfterChanges(ctx, watcher.Events, watcher.Errors) -} - -// readAfterChanges reads the rule files again once quietTime has passed -// without a change from events, until ctx is done, and logs the errors -// from errs. The wait starts at once, as if for a change, so that an edit -// saved after Load read the files, and before Dir was watched, is taken -// in too. -func (f *Files) readAfterChanges( - ctx context.Context, events <-chan fsnotify.Event, errs <-chan error, -) { - quiet := time.NewTimer(quietTime) - defer quiet.Stop() - - for { - select { - case <-ctx.Done(): - return - case <-events: - quiet.Reset(quietTime) - case <-quiet.C: - f.readAgain() - case err := <-errs: + // A change to any file in Dir counts. + watcher.CallWhenQuiet(ctx, + func(string) bool { return true }, + f.readAgain, + func(err error) { f.params.ProcessLog.Warn("watching the rule files failed", "error", err.Error()) - } - } + }, + ) } // readAgain reads the rule files again, in place of the rules loaded, or diff --git a/internal/rules/watch_internal_test.go b/internal/rules/watch_internal_test.go deleted file mode 100644 index a71b08b..0000000 --- a/internal/rules/watch_internal_test.go +++ /dev/null @@ -1,165 +0,0 @@ -package rules - -import ( - "context" - "log/slog" - "net/http" - "net/http/httptest" - "os" - "path/filepath" - "slices" - "testing" - "testing/synctest" - "time" - - "github.com/fsnotify/fsnotify" - - "sneak.berlin/go/smallwebwaf/internal/alerts" -) - -// The tests below run readAfterChanges in a synctest bubble, where time is -// a clock of the test's own: time.Sleep moves it on at once, and -// synctest.Wait returns once readAfterChanges waits again, so that every -// reading due by then is done. The test sends the changes itself, as the -// watch of a directory cannot run in a bubble. - -func TestFileWrittenInTwoPartsTakenInOnlyWhole(t *testing.T) { - t.Parallel() - - synctest.Test(t, func(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "50-app.rules") - writeFile(t, path, "first path block ^/first\n") - files := load(t, dir) - changes := run(t, files) - - file, err := os.Create(path) //nolint:gosec // a file the test wrote - if err != nil { - t.Fatalf("create: %v", err) - } - - defer func() { - _ = file.Close() - }() - - // The first part ends in the middle of a ban rule's regex, which, - // read then, would ban every request. - write(t, file, "first path block ^/first\nprobe path ban ^/") - - changes <- fsnotify.Event{Name: path, Op: fsnotify.Write} - - time.Sleep(quietTime - time.Nanosecond) - synctest.Wait() - wantMatched(t, files, "/anything") - - // The second part starts the wait again. - write(t, file, `\.env$`+"\n") - - changes <- fsnotify.Event{Name: path, Op: fsnotify.Write} - - time.Sleep(quietTime - time.Nanosecond) - synctest.Wait() - wantMatched(t, files, "/.env") - - time.Sleep(time.Nanosecond) - synctest.Wait() - wantMatched(t, files, "/.env", "probe") - wantMatched(t, files, "/anything") - }) -} - -func TestEditSavedBeforeTheWatchStartsTakenIn(t *testing.T) { - t.Parallel() - - synctest.Test(t, func(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "50-app.rules") - writeFile(t, path, "first path block ^/first\n") - files := load(t, dir) - - // Saved after Load read the files, and before the directory was - // watched, so that no change is seen for it. - writeFile(t, path, "first path block ^/edited\n") - run(t, files) - time.Sleep(quietTime) - synctest.Wait() - wantMatched(t, files, "/edited", "first") - }) -} - -// load loads the rules in dir. -func load(t *testing.T, dir string) *Files { - t.Helper() - - files, err := Load(Params{ - Dir: dir, Enabled: true, ProcessLog: slog.New(slog.DiscardHandler), - Alerts: alerts.New(alerts.Params{}), - }) - if err != nil { - t.Fatalf("load: %v", err) - } - - return files -} - -// run runs files' readAfterChanges until the test ends, and returns the -// channel that sends it changes. -func run(t *testing.T, files *Files) chan<- fsnotify.Event { - t.Helper() - - changes := make(chan fsnotify.Event) - ctx, stop := context.WithCancel(t.Context()) - stopped := make(chan struct{}) - - go func() { - files.readAfterChanges(ctx, changes, nil) - close(stopped) - }() - - t.Cleanup(func() { - stop() - <-stopped - }) - - return changes -} - -// writeFile writes content to the file at path. -func writeFile(t *testing.T, path, content string) { - t.Helper() - - err := os.WriteFile(path, []byte(content), 0o600) - if err != nil { - t.Fatalf("write %s: %v", path, err) - } -} - -// write writes text to the end of file. -func write(t *testing.T, file *os.File, text string) { - t.Helper() - - _, err := file.WriteString(text) - if err != nil { - t.Fatalf("write: %v", err) - } -} - -// wantMatched checks the ids of the rules that a GET request for path -// matches, in order. -func wantMatched(t *testing.T, files *Files, path string, want ...string) { - t.Helper() - - r := httptest.NewRequestWithContext(t.Context(), http.MethodGet, - "http://app.example"+path, nil) - - matched := files.Match(r) - - got := make([]string, 0, len(matched)) - for _, rule := range matched { - got = append(got, rule.ID) - } - - if !slices.Equal(got, want) { - t.Errorf("%s matched %v, want %v", path, got, want) - } -}