// Package web serves an optional htmx based UI and a small JSON API. package web import ( "context" "crypto/rand" "crypto/subtle" "embed" "encoding/hex" "encoding/json" "fmt" "html/template" "io/fs" "net" "net/http" "strings" "time" "github.com/illustris/i-am-gcroot/internal/filter" "github.com/illustris/i-am-gcroot/internal/roots" ) //go:embed templates/*.html static/* var assets embed.FS type Options struct { Addr string NoAuth bool Force bool } type Server struct { set *roots.Set opts Options token string tmpl *template.Template ctx context.Context } func New(ctx context.Context, set *roots.Set, opts Options) (*Server, error) { b := make([]byte, 16) if _, err := rand.Read(b); err != nil { return nil, err } funcs := template.FuncMap{ "size": filter.HumanSize, "age": func(t time.Time) string { return filter.HumanAge(t, time.Now()) }, "kinds": func() []roots.Kind { return roots.AllKinds }, "sorts": func() []string { return filter.SortNames }, } tmpl, err := template.New("").Funcs(funcs).ParseFS(assets, "templates/*.html") if err != nil { return nil, err } return &Server{set: set, opts: opts, token: hex.EncodeToString(b), tmpl: tmpl, ctx: ctx}, nil } // Listen binds the address and returns the URL to open (including the token). func (s *Server) Listen() (net.Listener, string, error) { ln, err := net.Listen("tcp", s.opts.Addr) if err != nil { return nil, "", err } url := "http://" + ln.Addr().String() + "/" if !s.opts.NoAuth { url += "?token=" + s.token } return ln, url, nil } func (s *Server) Serve(ln net.Listener) error { srv := &http.Server{Handler: s.Handler(), ReadHeaderTimeout: 10 * time.Second} go func() { <-s.ctx.Done() srv.Close() }() err := srv.Serve(ln) if err == http.ErrServerClosed { return nil } return err } func (s *Server) Handler() http.Handler { mux := http.NewServeMux() static, _ := fs.Sub(assets, "static") mux.Handle("GET /static/", http.StripPrefix("/static/", http.FileServerFS(static))) mux.HandleFunc("GET /{$}", s.index) mux.HandleFunc("GET /rows", s.rows) mux.HandleFunc("POST /delete", s.deleteHTML) mux.HandleFunc("POST /gc", s.gcHTML) mux.HandleFunc("POST /refresh", s.refreshHTML) mux.HandleFunc("GET /api/roots", s.apiRoots) mux.HandleFunc("POST /api/delete", s.apiDelete) mux.HandleFunc("POST /api/gc", s.apiGC) return s.auth(mux) } const cookieName = "i-am-gcroot-token" // auth accepts the token as ?token=, a cookie, or a bearer header. A valid // ?token= sets the cookie so the UI keeps working without it in the URL. // Mutating requests from the browser must also carry X-Token (htmx sends it) // so a cross-site form post cannot ride the cookie. func (s *Server) auth(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if s.opts.NoAuth || strings.HasPrefix(r.URL.Path, "/static/") { next.ServeHTTP(w, r) return } ok := func(t string) bool { return subtle.ConstantTimeCompare([]byte(t), []byte(s.token)) == 1 } header := r.Header.Get("X-Token") if h := r.Header.Get("Authorization"); strings.HasPrefix(h, "Bearer ") { header = strings.TrimPrefix(h, "Bearer ") } if r.Method != http.MethodGet { if !ok(header) { http.Error(w, "missing or bad token", http.StatusUnauthorized) return } next.ServeHTTP(w, r) return } if q := r.URL.Query().Get("token"); ok(q) { http.SetCookie(w, &http.Cookie{Name: cookieName, Value: s.token, Path: "/", HttpOnly: true, SameSite: http.SameSiteStrictMode}) next.ServeHTTP(w, r) return } if c, err := r.Cookie(cookieName); (err == nil && ok(c.Value)) || ok(header) { next.ServeHTTP(w, r) return } http.Error(w, "missing or bad token; use the URL printed at startup", http.StatusUnauthorized) }) } type viewParams struct { Query string Kinds map[roots.Kind]bool Sort string Desc bool Hidden bool Err string Rows []roots.Root Total int Status roots.Status Token string Message string Results []roots.Result Checked map[string]bool } type deleteOutcome struct { Results []roots.Result `json:"results"` Collected *roots.CollectResult `json:"collected,omitempty"` GCError string `json:"gcError,omitempty"` } func (s *Server) params(r *http.Request) viewParams { _ = r.ParseForm() p := viewParams{Query: r.Form.Get("q"), Sort: r.Form.Get("sort"), Desc: r.Form.Get("desc") != "", Hidden: r.Form.Get("hidden") != "", Checked: map[string]bool{}} for _, l := range r.Form["link"] { p.Checked[l] = true } if s.opts.NoAuth { p.Token = "" } else { p.Token = s.token } p.Kinds = map[roots.Kind]bool{} if ks, ok := r.Form["kind"]; ok || r.Form.Get("kinds") != "" { for _, k := range ks { p.Kinds[roots.Kind(k)] = true } } else { for _, k := range roots.AllKinds { p.Kinds[k] = k != roots.KindRuntime } } if p.Sort == "" { p.Sort = "age" } if p.Kinds[roots.KindRuntime] && !s.set.Status().Runtime { s.set.SetRuntime(true) _ = s.set.Refresh(s.ctx) } q, err := filter.Parse(p.Query) if err != nil { p.Err = err.Error() q, _ = filter.Parse("") } all := s.set.Snapshot() p.Total = len(all) p.Rows = filter.Apply(all, q, p.Kinds, p.Hidden, filter.ParseSort(p.Sort), p.Desc) p.Status = s.set.Status() return p } func (s *Server) render(w http.ResponseWriter, name string, data any) { w.Header().Set("Content-Type", "text/html; charset=utf-8") if err := s.tmpl.ExecuteTemplate(w, name, data); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } } func (s *Server) index(w http.ResponseWriter, r *http.Request) { s.render(w, "index.html", s.params(r)) } func (s *Server) rows(w http.ResponseWriter, r *http.Request) { s.render(w, "rows", s.params(r)) } func (s *Server) doDelete(r *http.Request, links []string, dry, collect bool) deleteOutcome { rs := s.set.Lookup(links) out := deleteOutcome{Results: roots.Delete(r.Context(), s.set.Cfg, rs, roots.DeleteOpts{DryRun: dry, Force: s.opts.Force})} if dry { return out } gone := map[string]bool{} for _, x := range out.Results { if x.OK() { gone[x.Link] = true } } s.set.Remove(gone) defer s.set.Refresh(s.ctx) if collect { c, err := roots.Collect(r.Context(), s.set.Cfg, roots.CollectedTargets(out.Results)) out.Collected = &c if err != nil { out.GCError = err.Error() } } return out } func (s *Server) deleteHTML(w http.ResponseWriter, r *http.Request) { _ = r.ParseForm() dry := r.Form.Get("dry") != "" out := s.doDelete(r, r.Form["link"], dry, r.Form.Get("collect") != "") res := out.Results p := s.params(r) p.Results = res ok := 0 for _, x := range res { if x.OK() { ok++ } } if dry { p.Message = fmt.Sprintf("Dry run: %d action(s)", len(res)) } else { p.Message = fmt.Sprintf("Deleted %d of %d root(s)", ok, len(res)) if out.Collected != nil { p.Message += "; " + out.Collected.String() } p.Err = out.GCError } s.render(w, "rows", p) } func (s *Server) gcHTML(w http.ResponseWriter, r *http.Request) { summary, err := roots.GC(r.Context(), s.set.Cfg) _ = s.set.Refresh(s.ctx) p := s.params(r) if err != nil { p.Err = err.Error() } else { p.Message = "GC: " + summary } s.render(w, "rows", p) } func (s *Server) refreshHTML(w http.ResponseWriter, r *http.Request) { p := viewParams{} if err := s.set.Refresh(s.ctx); err != nil { p.Err = err.Error() } p2 := s.params(r) p2.Err = p.Err p2.Message = "Rescanned" s.render(w, "rows", p2) } func writeJSON(w http.ResponseWriter, v any) { w.Header().Set("Content-Type", "application/json") enc := json.NewEncoder(w) enc.SetIndent("", " ") _ = enc.Encode(v) } func (s *Server) apiRoots(w http.ResponseWriter, r *http.Request) { p := s.params(r) if p.Err != "" { http.Error(w, p.Err, http.StatusBadRequest) return } writeJSON(w, p.Rows) } type deleteReq struct { Links []string `json:"links"` DryRun bool `json:"dryRun"` Collect bool `json:"collect"` } func (s *Server) apiDelete(w http.ResponseWriter, r *http.Request) { var req deleteReq if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } writeJSON(w, s.doDelete(r, req.Links, req.DryRun, req.Collect)) } func (s *Server) apiGC(w http.ResponseWriter, r *http.Request) { summary, err := roots.GC(r.Context(), s.set.Cfg) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } _ = s.set.Refresh(s.ctx) writeJSON(w, map[string]string{"summary": summary}) }