First commit Go counter service

internal/watcher/watcher.go

@@ -0,0 +1,151 @@
+// Package watcher reloads the domains CDB when the file changes on disk.
+//
+// It is the table mode of rcptd's watcher, trimmed: it watches the files
+// themselves (kqueue on FreeBSD/macOS only reports in-place writes through a
+// file watch) and their directories (an atomic `mv` over the file shows up as
+// a Create in the directory), debounces bursts and calls one reload function.
+package watcher
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+)
+
+// ReloadFunc is called, debounced, after a watched file changed. Its error is
+// logged; the watcher keeps running either way.
+type ReloadFunc func() error
+
+// Watcher watches a set of files and calls reload on change.
+type Watcher struct {
+	reload   ReloadFunc
+	fsw      *fsnotify.Watcher
+	files    map[string]bool // absolute paths we care about
+	debounce time.Duration
+
+	done     chan struct{}
+	stopOnce sync.Once
+	wg       sync.WaitGroup
+
+	timerMu sync.Mutex
+	timer   *time.Timer
+	runMu   sync.Mutex // serialises reload calls
+}
+
+// New watches paths. Their directories must exist; the files themselves may
+// appear later (the first deploy of the CDB triggers a reload).
+func New(paths []string, reload ReloadFunc) (*Watcher, error) {
+	fsw, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+	w := &Watcher{
+		reload:   reload,
+		fsw:      fsw,
+		files:    make(map[string]bool, len(paths)),
+		debounce: 500 * time.Millisecond,
+		done:     make(chan struct{}),
+	}
+	dirs := map[string]bool{}
+	for _, p := range paths {
+		abs, err := filepath.Abs(p)
+		if err != nil {
+			fsw.Close()
+			return nil, fmt.Errorf("resolve path %s: %w", p, err)
+		}
+		w.files[abs] = true
+		if dir := filepath.Dir(abs); !dirs[dir] {
+			if err := fsw.Add(dir); err != nil {
+				fsw.Close()
+				return nil, fmt.Errorf("watch directory %s: %w", dir, err)
+			}
+			dirs[dir] = true
+		}
+	}
+	for abs := range w.files {
+		if _, err := os.Stat(abs); err == nil {
+			_ = fsw.Add(abs)
+		}
+	}
+	return w, nil
+}
+
+// Start begins watching in a background goroutine.
+func (w *Watcher) Start() {
+	w.wg.Add(1)
+	go func() {
+		defer w.wg.Done()
+		for {
+			select {
+			case event, ok := <-w.fsw.Events:
+				if !ok {
+					return
+				}
+				if event.Op&(fsnotify.Write|fsnotify.Create) == 0 {
+					continue
+				}
+				abs, err := filepath.Abs(event.Name)
+				if err != nil || !w.files[abs] {
+					continue
+				}
+				// After a rename-over the old file watch is stale: re-add it so
+				// in-place writes to the new inode are seen too.
+				if event.Op&fsnotify.Create != 0 {
+					_ = w.fsw.Add(abs)
+				}
+				w.schedule()
+			case err, ok := <-w.fsw.Errors:
+				if !ok {
+					return
+				}
+				slog.Error("file watcher error", "error", err)
+			case <-w.done:
+				return
+			}
+		}
+	}()
+}
+
+// schedule (re)arms the debounce timer.
+func (w *Watcher) schedule() {
+	w.timerMu.Lock()
+	defer w.timerMu.Unlock()
+	if w.timer != nil {
+		w.timer.Stop()
+	}
+	w.timer = time.AfterFunc(w.debounce, w.run)
+}
+
+func (w *Watcher) run() {
+	select {
+	case <-w.done:
+		return
+	default:
+	}
+	w.runMu.Lock()
+	defer w.runMu.Unlock()
+	if err := w.reload(); err != nil {
+		slog.Error("reload after file change failed", "error", err)
+		return
+	}
+	slog.Info("reloaded after file change")
+}
+
+// Stop ends watching and waits for the goroutine; safe to call twice.
+func (w *Watcher) Stop() {
+	w.stopOnce.Do(func() {
+		w.timerMu.Lock()
+		if w.timer != nil {
+			w.timer.Stop()
+		}
+		w.timerMu.Unlock()
+		close(w.done)
+		w.fsw.Close()
+		w.wg.Wait()
+	})
+}