Files
skillshare/internal/server/handler_collect.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

175 lines
4.2 KiB
Go

package server
import (
"encoding/json"
"net/http"
"os"
"path/filepath"
"time"
ssync "skillshare/internal/sync"
)
// --- Scan types ---
type localSkillItem struct {
Name string `json:"name"`
Path string `json:"path"`
TargetName string `json:"targetName"`
Size int64 `json:"size"`
ModTime string `json:"modTime"`
}
type scanTarget struct {
TargetName string `json:"targetName"`
Skills []localSkillItem `json:"skills"`
}
// --- Collect types ---
type collectSkillRef struct {
Name string `json:"name"`
TargetName string `json:"targetName"`
}
// handleCollectScan scans targets for local (non-symlinked) skills.
// GET /api/collect/scan?target=<name> (optional filter)
func (s *Server) handleCollectScan(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
source := s.cfg.Source
targets := s.cloneTargets()
s.mu.RUnlock()
filterTarget := r.URL.Query().Get("target")
var scanTargets []scanTarget
totalCount := 0
for name, target := range targets {
if filterTarget != "" && filterTarget != name {
continue
}
locals, err := ssync.FindLocalSkills(target.Path, source)
if err != nil {
writeError(w, http.StatusInternalServerError, "scan failed for "+name+": "+err.Error())
return
}
items := make([]localSkillItem, 0, len(locals))
for _, sk := range locals {
items = append(items, localSkillItem{
Name: sk.Name,
Path: sk.Path,
TargetName: name,
Size: ssync.CalculateDirSize(sk.Path),
ModTime: sk.ModTime.Format(time.RFC3339),
})
}
totalCount += len(items)
scanTargets = append(scanTargets, scanTarget{
TargetName: name,
Skills: items,
})
}
if scanTargets == nil {
scanTargets = []scanTarget{}
}
writeJSON(w, map[string]any{
"targets": scanTargets,
"totalCount": totalCount,
})
}
// handleCollect pulls selected local skills from targets to source.
// POST /api/collect { skills: [{name, targetName}], force: bool }
func (s *Server) handleCollect(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body struct {
Skills []collectSkillRef `json:"skills"`
Force bool `json:"force"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
return
}
if len(body.Skills) == 0 {
writeError(w, http.StatusBadRequest, "no skills specified")
return
}
// Resolve each skill ref to a LocalSkillInfo
var resolved []ssync.LocalSkillInfo
for _, ref := range body.Skills {
target, ok := s.cfg.Targets[ref.TargetName]
if !ok {
writeError(w, http.StatusBadRequest, "unknown target: "+ref.TargetName)
return
}
skillPath := filepath.Join(target.Path, ref.Name)
info, err := os.Lstat(skillPath)
if err != nil {
writeError(w, http.StatusBadRequest, "skill not found: "+ref.Name+" in "+ref.TargetName)
return
}
if info.Mode()&os.ModeSymlink != 0 {
writeError(w, http.StatusBadRequest, "skill is a symlink (not local): "+ref.Name)
return
}
if !info.IsDir() {
writeError(w, http.StatusBadRequest, "skill is not a directory: "+ref.Name)
return
}
resolved = append(resolved, ssync.LocalSkillInfo{
Name: ref.Name,
Path: skillPath,
TargetName: ref.TargetName,
})
}
result, err := ssync.PullSkills(resolved, s.cfg.Source, ssync.PullOptions{
Force: body.Force,
})
if err != nil {
writeError(w, http.StatusInternalServerError, "collect failed: "+err.Error())
return
}
// Convert Failed map to string values for JSON
failed := make(map[string]string, len(result.Failed))
for k, v := range result.Failed {
failed[k] = v.Error()
}
status := "ok"
msg := ""
if len(result.Failed) > 0 {
status = "partial"
msg = "some skills failed to collect"
}
s.writeOpsLog("collect", status, start, map[string]any{
"skills_selected": len(body.Skills),
"skills_pulled": len(result.Pulled),
"skills_skipped": len(result.Skipped),
"skills_failed": len(result.Failed),
"force": body.Force,
"scope": "ui",
}, msg)
writeJSON(w, map[string]any{
"pulled": result.Pulled,
"skipped": result.Skipped,
"failed": failed,
})
}