326 lines
8.4 KiB
Go
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})
|
|
}
|