From bb51a973aeab6d4880698e016ae317bde5ca35f3 Mon Sep 17 00:00:00 2001 From: sneak Date: Thu, 19 Nov 2026 16:31:57 +0000 Subject: [PATCH] rproxy: one type for the goroutines sending reports (closes #433) handler held a WaitGroup, a mutex and a stopped flag for the reports, and the rule that no report starts once waiting has begun was split between sendReport and Server.WaitForReports. reportGoroutines now holds all three, and its two methods are the only code that touches the lock and the flag. Model: opus-5-5 --- internal/rproxy/rproxy.go | 14 +++---------- internal/rproxy/waf.go | 41 +++++++++++++++++++++++++++++++-------- 2 files changed, 36 insertions(+), 19 deletions(-) diff --git a/internal/rproxy/rproxy.go b/internal/rproxy/rproxy.go index 489c4c6..08eeee1 100644 --- a/internal/rproxy/rproxy.go +++ b/internal/rproxy/rproxy.go @@ -20,7 +20,6 @@ import ( "net/url" "slices" "strings" - "sync" "time" "sneak.berlin/go/smallwebwaf/internal/config" @@ -113,11 +112,7 @@ func New(params Params) *Server { // which SWW_RPROXY_WAF_BACKEND_TIMEOUT_MS bounds. Any report after this call // is dropped: that of a WebSocket that closes while rproxy stops, for one. func (s *Server) WaitForReports() { - s.h.reportsMu.Lock() - s.h.reportsStopped = true - s.h.reportsMu.Unlock() - - s.h.reports.Wait() + s.h.reports.stopAndWait() } // handler is the proxy. It holds what every request shares; what belongs to @@ -135,11 +130,8 @@ type handler struct { reportURL string // breaker is the circuit breaker for asks to waf. breaker breaker - // reports waits for the reports being sent. reportsMu guards starting one - // against reportsStopped, which is set once nothing is to wait for another. - reports sync.WaitGroup - reportsMu sync.Mutex - reportsStopped bool + // reports are the goroutines sending reports to waf. + reports reportGoroutines } // newTransport returns what carries requests to the app. It never goes through diff --git a/internal/rproxy/waf.go b/internal/rproxy/waf.go index 630329b..9d22847 100644 --- a/internal/rproxy/waf.go +++ b/internal/rproxy/waf.go @@ -10,6 +10,7 @@ import ( "maps" "net/http" "strings" + "sync" "time" "sneak.berlin/go/smallwebwaf/internal/waf" @@ -254,14 +255,7 @@ func (rq *request) answerWith(answer *wafAnswer) { // visitor does not wait for it. The report goes on after ctx, the request's own // context, has ended. func (h *handler) sendReport(ctx context.Context, report *waf.Report) { - h.reportsMu.Lock() - defer h.reportsMu.Unlock() - - if h.reportsStopped { - return - } - - h.reports.Go(func() { + h.reports.startUnlessStopped(func() { err := h.postReport(context.WithoutCancel(ctx), report) if err != nil { h.processLog.Warn("a report is dropped", "error", err.Error()) @@ -269,6 +263,37 @@ func (h *handler) sendReport(ctx context.Context, report *waf.Report) { }) } +// reportGoroutines are the goroutines sending reports to waf. None starts once +// stopAndWait has been called. +type reportGoroutines struct { + mu sync.Mutex + stopped bool + running sync.WaitGroup +} + +// startUnlessStopped runs send on a goroutine of its own, or drops it once +// stopAndWait has been called. +func (g *reportGoroutines) startUnlessStopped(send func()) { + g.mu.Lock() + defer g.mu.Unlock() + + if g.stopped { + return + } + + g.running.Go(send) +} + +// stopAndWait stops any more goroutines from starting, and returns once those +// running have ended. +func (g *reportGoroutines) stopAndWait() { + g.mu.Lock() + g.stopped = true + g.mu.Unlock() + + g.running.Wait() +} + // postReport posts report to waf, and waits for its answer for up to // SWW_RPROXY_WAF_BACKEND_TIMEOUT_MS. func (h *handler) postReport(ctx context.Context, report *waf.Report) error {