@yuuki824/kanshi 0.3.0

package/internal/server/server.go

@@ -0,0 +1,523 @@
+// Package server wires the poller, the storage scanner and the HTTP surface
+// together.
+package server
+
+import (
+	"compress/gzip"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/fs"
+	"net/http"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/rene-roid/kanshi/internal/access"
+	"github.com/rene-roid/kanshi/internal/config"
+	"github.com/rene-roid/kanshi/internal/dockerstats"
+	"github.com/rene-roid/kanshi/internal/roots"
+	"github.com/rene-roid/kanshi/internal/storage"
+	"github.com/rene-roid/kanshi/internal/vitals"
+)
+
+// Frame is one push to the browser. Vitals and Docker are explicit nulls
+// rather than omitted, because app.js tests each for truthiness. Storage is
+// only the walk queue's status: the page refetches the folder it shows when
+// a walk finishes, so nothing polls for it.
+type Frame struct {
+	Vitals  *vitals.Sample      `json:"vitals"`
+	Docker  *dockerstats.Result `json:"docker"`
+	Storage *storage.Status     `json:"storage"`
+	Error   string              `json:"error,omitempty"`
+}
+
+// Server holds the shared state the poller writes and the handlers read.
+type Server struct {
+	cfg     config.Config
+	version string
+	logf    func(format string, args ...any)
+	roots   *roots.Resolver
+	vitals  *vitals.Reader
+	docker  *dockerstats.Client
+	storage *storage.Scanner
+	assets  *assets
+
+	// base outlives any single request. Work that mutates shared state, such
+	// as a sample, is started under it rather than the request context, so a
+	// browser navigating away cannot abort it for everyone else.
+	base context.Context
+
+	mu      sync.RWMutex
+	latest  Frame
+	payload []byte // latest, already marshalled, for newly connected streams
+	subs    map[chan []byte]struct{}
+	lastSee time.Time
+
+	// wake releases the poller from its idle sleep. Buffered by one so a
+	// signal is never lost and no sender ever blocks.
+	wake chan struct{}
+
+	// access is set once Run starts listening. accessSource is where the
+	// current mode came from, which decides whether the page may change it.
+	access       *access.Manager
+	accessMu     sync.Mutex
+	accessSource config.Source
+	saveOnce     sync.Once
+	saveOK       bool
+
+	// OnReady, when set, runs once the dashboard is listening.
+	OnReady func()
+}
+
+func New(cfg config.Config, web fs.FS, version string, logf func(string, ...any)) (*Server, error) {
+	a, err := loadAssets(web, cfg.WebDir != "")
+	if err != nil {
+		return nil, err
+	}
+	r := roots.NewResolver(cfg.StorageRoots, cfg.HostRoot)
+	return &Server{
+		base:         context.Background(),
+		cfg:          cfg,
+		version:      version,
+		logf:         logf,
+		roots:        r,
+		vitals:       vitals.New(r),
+		docker:       dockerstats.New(cfg),
+		storage:      storage.New(cfg, r, logf),
+		assets:       a,
+		subs:         make(map[chan []byte]struct{}),
+		wake:         make(chan struct{}, 1),
+		accessSource: cfg.AccessSource,
+	}, nil
+}
+
+/* ── polling ────────────────────────────────────────────────────────────── */
+
+// sampleOnce takes one reading of both halves at the same moment. The vitals
+// read is pure /proc work, so it runs alongside the Docker round trips rather
+// than adding its latency to them.
+func (s *Server) sampleOnce(ctx context.Context) Frame {
+	var host vitals.Sample
+	var containers dockerstats.Result
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		host = s.vitals.Sample()
+	}()
+	containers = s.docker.Sample(ctx)
+	wg.Wait()
+
+	scan := s.storage.Status()
+	frame := Frame{Vitals: &host, Docker: &containers, Storage: &scan}
+	payload, err := json.Marshal(frame)
+	if err != nil {
+		payload, _ = json.Marshal(Frame{Error: err.Error()})
+	}
+	s.mu.Lock()
+	s.latest, s.payload = frame, payload
+	s.mu.Unlock()
+	return frame
+}
+
+// seed fills the delta baselines so the first frame shows real numbers.
+//
+// Both CPU readings are differences against a previous sample, so a cold poller
+// would otherwise publish a screen of zeros. One throwaway pass plus a short
+// gap costs ~1s and makes the first frame the user sees correct.
+func (s *Server) seed(ctx context.Context) {
+	s.vitals.Prime()
+	s.docker.Sample(ctx)
+	select {
+	case <-ctx.Done():
+		return
+	case <-time.After(time.Second):
+	}
+	s.vitals.Prime()
+}
+
+// Poll is the live loop. Once nobody has been connected for IdleTimeout it
+// stops touching /proc and the Docker daemon entirely, and sleeps until a
+// browser comes back.
+func (s *Server) Poll(ctx context.Context) {
+	timer := time.NewTimer(time.Hour)
+	timer.Stop()
+	defer timer.Stop()
+
+	s.seed(ctx)
+	for ctx.Err() == nil {
+		if s.idle() {
+			// Nobody is watching. The timer is only a safety net: waking
+			// here does nothing but check again, and the baselines are only
+			// re-seeded once a browser has actually come back.
+			timer.Reset(time.Minute)
+			select {
+			case <-ctx.Done():
+				return
+			case <-timer.C:
+			case <-s.wake:
+			}
+			timer.Stop()
+			if !s.idle() {
+				s.seed(ctx)
+			}
+			continue
+		}
+
+		s.sampleOnce(ctx)
+		if ctx.Err() != nil {
+			return
+		}
+		s.mu.RLock()
+		payload := s.payload
+		s.mu.RUnlock()
+		s.broadcast(payload)
+
+		timer.Reset(s.cfg.PollInterval)
+		select {
+		case <-ctx.Done():
+			return
+		case <-timer.C:
+		}
+	}
+}
+
+func (s *Server) idle() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.subs) == 0 && time.Since(s.lastSee) > s.cfg.IdleTimeout
+}
+
+// touch records browser activity and wakes an idle poller.
+func (s *Server) touch() {
+	s.mu.Lock()
+	s.lastSee = time.Now()
+	s.mu.Unlock()
+	signal(s.wake)
+}
+
+func signal(ch chan struct{}) {
+	select {
+	case ch <- struct{}{}:
+	default: // already pending
+	}
+}
+
+func (s *Server) broadcast(payload []byte) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	for ch := range s.subs {
+		select {
+		case ch <- payload:
+		default:
+			// The subscriber is behind. Drop its stale frame and hand it the
+			// fresh one — a slow phone must never stall the poller.
+			select {
+			case <-ch:
+			default:
+			}
+			select {
+			case ch <- payload:
+			default:
+			}
+		}
+	}
+}
+
+/* ── handlers ───────────────────────────────────────────────────────────── */
+
+func (s *Server) Handler() http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/vitals", s.handleVitals)
+	mux.HandleFunc("GET /api/containers", s.handleContainers)
+	mux.HandleFunc("GET /api/storage", s.handleStorage)
+	mux.HandleFunc("POST /api/storage/rescan", s.handleRescan)
+	mux.HandleFunc("GET /api/storage/dir", s.handleStorageDir)
+	mux.HandleFunc("GET /api/config", s.handleConfig)
+	mux.HandleFunc("GET /api/access", s.handleAccess)
+	mux.HandleFunc("POST /api/access", s.handleSetAccess)
+	mux.HandleFunc("GET /api/stream", s.handleStream)
+	mux.HandleFunc("GET /healthz", s.handleHealth)
+	mux.HandleFunc("GET /static/", s.assets.serveStatic)
+	mux.HandleFunc("GET /{$}", s.assets.serveIndex)
+	return mux
+}
+
+// Responses larger than this are gzipped for clients that accept it. Below
+// it the header overhead eats the saving.
+const gzipMin = 1024
+
+var gzipPool = sync.Pool{New: func() any {
+	w, _ := gzip.NewWriterLevel(io.Discard, gzip.BestSpeed)
+	return w
+}}
+
+func acceptsGzip(r *http.Request) bool {
+	return strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
+}
+
+func writeJSON(w http.ResponseWriter, r *http.Request, v any) {
+	body, err := json.Marshal(v)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	h := w.Header()
+	h.Set("Content-Type", "application/json")
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Vary", "Accept-Encoding")
+	if len(body) < gzipMin || !acceptsGzip(r) {
+		_, _ = w.Write(body)
+		return
+	}
+	h.Set("Content-Encoding", "gzip")
+	gz := gzipPool.Get().(*gzip.Writer)
+	gz.Reset(w)
+	_, _ = gz.Write(body)
+	_ = gz.Close()
+	gzipPool.Put(gz)
+}
+
+func (s *Server) handleVitals(w http.ResponseWriter, r *http.Request) {
+	s.touch()
+	s.mu.RLock()
+	latest := s.latest
+	s.mu.RUnlock()
+	if latest.Vitals == nil {
+		latest = s.sampleOnce(s.base)
+	}
+	writeJSON(w, r, latest.Vitals)
+}
+
+func (s *Server) handleContainers(w http.ResponseWriter, r *http.Request) {
+	s.touch()
+	s.mu.RLock()
+	latest := s.latest
+	s.mu.RUnlock()
+	if latest.Docker == nil {
+		latest = s.sampleOnce(s.base)
+	}
+	writeJSON(w, r, latest.Docker)
+}
+
+func (s *Server) handleStorage(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, r, s.storage.Snapshot())
+}
+
+// handleStorageDir reads one directory and sizes its subfolders from the
+// cache: /api/storage/dir?root=0&path=home/yuuki. Subfolders the cache is
+// missing come back pending, and are walked in the background.
+func (s *Server) handleStorageDir(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query()
+	root, err := strconv.Atoi(q.Get("root"))
+	if err != nil {
+		http.Error(w, "bad root", http.StatusBadRequest)
+		return
+	}
+	listing, ok := s.storage.List(root, q.Get("path"))
+	if !ok {
+		http.Error(w, "no such root", http.StatusNotFound)
+		return
+	}
+	writeJSON(w, r, listing)
+}
+
+// handleRescan re-walks the subfolders of one directory, named the same way
+// as for handleStorageDir. It has to come from the dashboard itself: the
+// custom header cannot be set by a plain form or an <img> on some other site,
+// so a page you happen to visit cannot keep your disks busy.
+func (s *Server) handleRescan(w http.ResponseWriter, r *http.Request) {
+	if !sameOrigin(r) {
+		http.Error(w, "forbidden", http.StatusForbidden)
+		return
+	}
+	q := r.URL.Query()
+	root, err := strconv.Atoi(q.Get("root"))
+	if err != nil {
+		http.Error(w, "bad root", http.StatusBadRequest)
+		return
+	}
+	status, ok := s.storage.Rescan(root, q.Get("path"))
+	if !ok {
+		http.Error(w, "no such root", http.StatusNotFound)
+		return
+	}
+	writeJSON(w, r, status)
+}
+
+func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, r, map[string]any{
+		"version":          s.version,
+		"os":               runtime.GOOS,
+		"poll_interval":    s.cfg.PollInterval.Seconds(),
+		"storage_interval": s.cfg.StorageInterval.Seconds(),
+		"tree_depth":       s.cfg.TreeDepth,
+	})
+}
+
+func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, r, map[string]bool{"ok": true})
+}
+
+func (s *Server) handleStream(w http.ResponseWriter, r *http.Request) {
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "streaming unsupported", http.StatusInternalServerError)
+		return
+	}
+
+	ch := make(chan []byte, 1)
+	s.mu.Lock()
+	s.subs[ch] = struct{}{}
+	s.mu.Unlock()
+	s.touch()
+	defer func() {
+		s.mu.Lock()
+		delete(s.subs, ch)
+		s.mu.Unlock()
+	}()
+
+	h := w.Header()
+	h.Set("Content-Type", "text/event-stream")
+	h.Set("Cache-Control", "no-cache, no-transform")
+	h.Set("X-Accel-Buffering", "no") // tell any reverse proxy not to buffer us
+	h.Set("Connection", "keep-alive")
+
+	// One gzip stream for the life of the connection. Consecutive frames are
+	// nearly identical, and deflate's window spans several of them, so each
+	// frame after the first shrinks to a few hundred bytes — a fraction of
+	// what a phone on mobile data would otherwise pull every tick.
+	var out io.Writer = w
+	var gz *gzip.Writer
+	if acceptsGzip(r) {
+		h.Set("Content-Encoding", "gzip")
+		h.Set("Vary", "Accept-Encoding")
+		gz, _ = gzip.NewWriterLevel(w, gzip.BestSpeed)
+		defer gz.Close()
+		out = gz
+	}
+	w.WriteHeader(http.StatusOK)
+	send := func(chunks ...string) {
+		for _, c := range chunks {
+			_, _ = io.WriteString(out, c)
+		}
+		if gz != nil {
+			_ = gz.Flush()
+		}
+		flusher.Flush()
+	}
+
+	// Hand the newcomer the last frame immediately, so a reconnecting phone
+	// paints real numbers instead of waiting out a poll interval.
+	s.mu.RLock()
+	payload := s.payload
+	s.mu.RUnlock()
+	if payload != nil {
+		send("data: ", string(payload), "\n\n")
+	} else {
+		send(": hello\n\n") // gets the headers and the gzip header out now
+	}
+
+	keepalive := time.NewTicker(25 * time.Second)
+	defer keepalive.Stop()
+
+	for {
+		select {
+		case <-r.Context().Done():
+			return
+		case <-s.base.Done():
+			// A stream never ends on its own, so without this every shutdown
+			// would sit out the full Shutdown grace period waiting on it.
+			return
+		case payload := <-ch:
+			s.touch()
+			send("data: ", string(payload), "\n\n")
+		case <-keepalive.C:
+			// Keeps mobile proxies from closing an idle stream.
+			send(": keepalive\n\n")
+		}
+	}
+}
+
+/* ── lifecycle ──────────────────────────────────────────────────────────── */
+
+// Run starts the background workers, listens according to mode, and serves
+// until ctx is cancelled.
+func (s *Server) Run(ctx context.Context, mode access.Mode) error {
+	// Assigned before the listener accepts anything, so no handler can observe
+	// the placeholder set in New.
+	s.base = ctx
+
+	srv := &http.Server{
+		Handler: s.Handler(),
+		// No write deadline: an SSE stream is meant to stay open indefinitely.
+		ReadHeaderTimeout: 10 * time.Second,
+		IdleTimeout:       65 * time.Second,
+	}
+	mgr := access.NewManager(s.cfg.Port, srv, s.logf)
+	if err := mgr.Apply(mode); err != nil {
+		return err
+	}
+	s.accessMu.Lock()
+	s.access = mgr
+	s.accessMu.Unlock()
+	s.banner(mode)
+	if s.OnReady != nil {
+		go s.OnReady()
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(3)
+	go func() { defer wg.Done(); s.Poll(ctx) }()
+	go func() { defer wg.Done(); s.storage.Loop(ctx) }()
+	go func() { defer wg.Done(); mgr.Watch(ctx) }()
+
+	<-ctx.Done()
+
+	shutdown, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	_ = srv.Shutdown(shutdown)
+	mgr.Close()
+	s.docker.Close()
+	wg.Wait()
+	s.storage.Close()
+	return nil
+}
+
+func (s *Server) banner(mode access.Mode) {
+	from := ""
+	switch s.accessSource {
+	case config.SourceFlag:
+		from = " (from --access)"
+	case config.SourceEnv:
+		from = " (from the environment)"
+	case config.SourceFile:
+		from = " (from " + s.cfg.File + ")"
+	}
+	fmt.Printf("kanshi %s — access: %s%s\n", s.version, mode, from)
+	for _, l := range s.access.Links() {
+		fmt.Printf("  %-10s %s\n", kindLabel(l.Kind)+":", l.URL)
+	}
+	if mode.All {
+		s.logf("warning: access \"all\" listens on every interface, and kanshi has no login")
+	}
+}
+
+func kindLabel(k access.Kind) string {
+	switch k {
+	case access.KindLocal:
+		return "Local"
+	case access.KindLAN:
+		return "LAN"
+	case access.KindTailscale:
+		return "Tailscale"
+	case access.KindCustom:
+		return "Address"
+	}
+	return "Other"
+}

package/internal/server/static.go

@@ -0,0 +1,165 @@
+package server
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/sha256"
+	"encoding/hex"
+	"io/fs"
+	"net/http"
+	"path"
+	"strconv"
+	"strings"
+)
+
+// asset is one embedded file, prepared once at startup: hashed for its ETag
+// and cache-busting URL, and gzipped ahead of time so no request pays for it.
+type asset struct {
+	body  []byte
+	gz    []byte // nil when compression would not help (PNGs, tiny files)
+	etag  string
+	ctype string
+}
+
+// assets serves the frontend.
+//
+// index.html refers to every other file as /static/<name>?v=<hash>. The hash
+// changes whenever the file does, so those URLs can be cached forever and a
+// returning phone downloads nothing but the page itself — which it only
+// revalidates, with a 304 when nothing changed.
+type assets struct {
+	dev   bool // KANSHI_WEB_DIR: read from disk on every request instead
+	web   fs.FS
+	index *asset
+	files map[string]*asset
+}
+
+func loadAssets(web fs.FS, dev bool) (*assets, error) {
+	a := &assets{dev: dev, web: web, files: make(map[string]*asset)}
+	if dev {
+		return a, nil
+	}
+	entries, err := fs.ReadDir(web, ".")
+	if err != nil {
+		return nil, err
+	}
+	for _, e := range entries {
+		if e.IsDir() || e.Name() == "index.html" {
+			continue
+		}
+		body, err := fs.ReadFile(web, e.Name())
+		if err != nil {
+			return nil, err
+		}
+		a.files[e.Name()] = newAsset(e.Name(), body)
+	}
+
+	index, err := fs.ReadFile(web, "index.html")
+	if err != nil {
+		return nil, err
+	}
+	for name, f := range a.files {
+		index = bytes.ReplaceAll(index, []byte(`"/static/`+name+`"`), []byte(`"/static/`+name+`?v=`+f.etag+`"`))
+	}
+	a.index = newAsset("index.html", index)
+	return a, nil
+}
+
+func newAsset(name string, body []byte) *asset {
+	sum := sha256.Sum256(body)
+	a := &asset{body: body, etag: hex.EncodeToString(sum[:8]), ctype: contentType(name)}
+	if strings.HasPrefix(a.ctype, "text/") || strings.HasPrefix(a.ctype, "image/svg") {
+		var buf bytes.Buffer
+		gz, _ := gzip.NewWriterLevel(&buf, gzip.BestCompression)
+		_, _ = gz.Write(body)
+		_ = gz.Close()
+		if buf.Len() < len(body)*9/10 {
+			a.gz = buf.Bytes()
+		}
+	}
+	return a
+}
+
+// contentType is a fixed table rather than mime.TypeByExtension, which on
+// Windows reads the registry — where a stray install can map .js to
+// text/plain and stop the browser from running the script.
+func contentType(name string) string {
+	switch path.Ext(name) {
+	case ".html":
+		return "text/html; charset=utf-8"
+	case ".css":
+		return "text/css; charset=utf-8"
+	case ".js":
+		return "text/javascript; charset=utf-8"
+	case ".svg":
+		return "image/svg+xml"
+	case ".png":
+		return "image/png"
+	case ".ico":
+		return "image/x-icon"
+	case ".json", ".webmanifest":
+		return "application/json"
+	}
+	return "application/octet-stream"
+}
+
+func (a *assets) serveIndex(w http.ResponseWriter, r *http.Request) {
+	if a.dev {
+		a.serveDev(w, r, "index.html")
+		return
+	}
+	a.write(w, r, a.index, false)
+}
+
+func (a *assets) serveStatic(w http.ResponseWriter, r *http.Request) {
+	name := strings.TrimPrefix(r.URL.Path, "/static/")
+	if a.dev {
+		a.serveDev(w, r, name)
+		return
+	}
+	f := a.files[name]
+	if f == nil {
+		http.NotFound(w, r)
+		return
+	}
+	a.write(w, r, f, r.URL.Query().Get("v") == f.etag)
+}
+
+func (a *assets) write(w http.ResponseWriter, r *http.Request, f *asset, immutable bool) {
+	h := w.Header()
+	h.Set("Content-Type", f.ctype)
+	h.Set("Vary", "Accept-Encoding")
+	if immutable {
+		h.Set("Cache-Control", "public, max-age=31536000, immutable")
+	} else {
+		h.Set("Cache-Control", "no-cache")
+	}
+	// Weak, because the gzipped and plain bodies share it.
+	h.Set("ETag", `W/"`+f.etag+`"`)
+	if strings.Contains(r.Header.Get("If-None-Match"), `"`+f.etag+`"`) {
+		w.WriteHeader(http.StatusNotModified)
+		return
+	}
+	body := f.body
+	if f.gz != nil && acceptsGzip(r) {
+		h.Set("Content-Encoding", "gzip")
+		body = f.gz
+	}
+	h.Set("Content-Length", strconv.Itoa(len(body)))
+	if r.Method != http.MethodHead {
+		_, _ = w.Write(body)
+	}
+}
+
+// serveDev reads straight from KANSHI_WEB_DIR, uncached, so an edit shows up
+// on the next reload.
+func (a *assets) serveDev(w http.ResponseWriter, r *http.Request, name string) {
+	body, err := fs.ReadFile(a.web, name)
+	if err != nil {
+		http.NotFound(w, r)
+		return
+	}
+	w.Header().Set("Content-Type", contentType(name))
+	w.Header().Set("Cache-Control", "no-store")
+	_, _ = w.Write(body)
+}