Files
skillshare/internal/server/handler_audit_stream.go
T
Willie 5307b3276e fix(server): use snapshot pattern to eliminate map races and narrow lock scope
Addresses P1 and P2 from code review on the RWMutex commit:

P1 — Stream handlers now snapshot config under RLock before streaming:
- handleDiffStream: clone Targets map to prevent concurrent map panic
- handleCheckStream, handleAuditStream: snapshot source/projectRoot
- handleUpdateStream: snapshot source (per-item Lock already correct)

P2 — All read handlers now use narrow snapshot instead of defer RUnlock:
- RLock → copy needed fields to locals → RUnlock → do work with locals
- Prevents slow I/O (git fetch, version check, audit scan) from blocking
  the auto-reload middleware's exclusive Lock on concurrent requests

Other changes:
- computeTargetDiff takes source parameter (no more s.cfg.Source access)
- Add cloneTargets() helper for safe map copying
- Add writeOpsLogTo/writeAuditLogTo for lock-free oplog writes
2026-03-17 04:48:42 +08:00

81 lines
2.0 KiB
Go

package server
import (
"net/http"
"sync"
"sync/atomic"
"time"
"skillshare/internal/audit"
)
// handleAuditStream serves an SSE endpoint that streams audit progress in real time.
// Events:
// - "start" → {"total": N} after skill discovery
// - "progress" → {"scanned": N} every 200ms during scan
// - "done" → {"results":…,"summary":…} final payload (same shape as GET /api/audit)
func (s *Server) handleAuditStream(w http.ResponseWriter, r *http.Request) {
safeSend, ok := initSSE(w)
if !ok {
return
}
start := time.Now()
// Snapshot config under RLock, then release before slow I/O.
s.mu.RLock()
source := s.cfg.Source
projectRoot := s.projectRoot
policy := s.auditPolicy()
s.mu.RUnlock()
// 1. Discover skills
skills, err := discoverAuditSkills(source)
if err != nil {
safeSend("error", map[string]string{"error": err.Error()})
return
}
safeSend("start", map[string]int{"total": len(skills)})
// 2. Atomic counter + ticker for progress events
var scanned atomic.Int64
ctx := r.Context()
done := make(chan struct{})
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
ticker := time.NewTicker(200 * time.Millisecond)
defer ticker.Stop()
for {
select {
case <-ticker.C:
safeSend("progress", map[string]int64{"scanned": scanned.Load()})
case <-done:
return
case <-ctx.Done():
return
}
}
}()
onDone := func() { scanned.Add(1) }
// 3. Parallel scan (blocks until all skills are scanned)
outputs := audit.ParallelScan(skillsToAuditInputs(skills), projectRoot, onDone, nil)
close(done) // signal ticker goroutine to stop
wg.Wait() // wait for it to fully exit before writing to w
// 4. Process results
agg := processAuditResults(skills, outputs, policy)
s.writeAuditLog(agg.Status, start, agg.LogArgs, agg.Message)
// 5. Send final result (no concurrent writers at this point)
safeSend("done", map[string]any{
"results": agg.Results,
"summary": agg.Summary,
})
}