Files
i-am-gcroot/internal/web/server.go
T
2026-10-28 08:00:16 +05:30

326 lines
8.4 KiB
Go

// 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})
}