@yuuki824/kanshi 0.3.0

package/internal/storage/walk.go

@@ -0,0 +1,342 @@
+package storage
+
+import (
+	"context"
+	"os"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/rene-roid/kanshi/internal/roots"
+)
+
+// Largest individual files named in a listing. Everything past this is still
+// counted, just not named.
+const topFiles = 32
+
+// dirNode is one directory within TreeDepth of where the walk started. Deeper
+// directories have their bytes rolled into the nearest retained ancestor
+// rather than getting a node of their own.
+type dirNode struct {
+	name       string
+	bytes      int64 // files directly inside, plus everything below the retained depth
+	size       int64 // bytes + children
+	unreadable int32 // directories at or below this one the walk could not enter
+	children   []int32
+}
+
+// tree is one walk. nodes is in breadth-first order, so every parent comes
+// before all of its children and nodes[0] is where the walk started.
+type tree struct {
+	nodes []*dirNode
+}
+
+// dirEntry is one directory entry as the platform's reader reports it. name
+// points into the reader's buffer and is only valid until its next read.
+type dirEntry struct {
+	name []byte
+	dir  bool
+	dev  uint64 // directories: the filesystem, so the walk never crosses into another
+	size int64  // files: bytes allocated on disk
+	key  uint64 // files that may have other hard links: counted once per key
+}
+
+// walker carries what stays the same across every walk of one batch.
+type walker struct {
+	maxDepth int
+	excluded map[string]bool
+	progress *atomic.Int64
+	pace     *throttle
+	rd       *dirReader
+}
+
+// frontier is one BFS level: every directory path back to back in a single
+// buffer, each NUL-terminated so it can go straight to the kernel. One growing
+// buffer per level rather than a string per directory — on a tree with a wide
+// node_modules or overlay2 level, the string headers and allocator rounding
+// alone would cost more than the paths.
+type frontier struct {
+	paths []byte
+	dirs  []queued
+}
+
+// queued is a directory waiting its turn. node is the retained node its files
+// are counted into: its own when own is set, otherwise its nearest retained
+// ancestor.
+type queued struct {
+	start, end uint32 // its path is paths[start:end], with a NUL at end
+	node       int32
+	depth      uint16 // below where the walk started
+	own        bool
+	dedupe     bool // Windows: inside the system directory, where hard links live
+}
+
+func (f *frontier) path(q queued) []byte { return f.paths[q.start:q.end] }
+
+func (f *frontier) push(parent, name []byte, q queued) queued {
+	q.start = uint32(len(f.paths))
+	f.paths = append(f.paths, parent...)
+	if parent[len(parent)-1] != pathSep {
+		f.paths = append(f.paths, pathSep)
+	}
+	f.paths = append(f.paths, name...)
+	q.end = uint32(len(f.paths))
+	f.paths = append(f.paths, 0)
+	f.dirs = append(f.dirs, q)
+	return q
+}
+
+// pop takes back the last push.
+func (f *frontier) pop(q queued) {
+	f.paths = f.paths[:q.start]
+	f.dirs = f.dirs[:len(f.dirs)-1]
+}
+
+func (f *frontier) reset() {
+	f.paths = f.paths[:0]
+	f.dirs = f.dirs[:0]
+}
+
+// walk sizes one folder with a level-by-level BFS. Only directories within
+// maxDepth of the start get a node of their own; anything deeper is still
+// fully traversed and counted, but its bytes roll up into the nearest retained
+// ancestor. (Walking all of / on the host this was written for retains ~2.3k
+// nodes instead of ~96k.)
+//
+// Going breadth-first means the frontier is never more than two levels of
+// paths, and the retained levels are all finished before the deep, bulky part
+// of the tree starts. Directories are opened by full path, so no descriptor is
+// held open while its children wait in the queue.
+func (w *walker) walk(ctx context.Context, rootPath string) (*tree, error) {
+	rootDev, err := rootDevice(rootPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// Windows de-duplicates hard links only inside its system directory. The
+	// walk is either inside it already, or may pass it at a known depth.
+	rootDedupe, sysLevel, sysKey := false, -1, ""
+	if sys := systemRoot(); sys != "" {
+		switch {
+		case roots.Within(sys, rootPath):
+			rootDedupe = true
+		case roots.Within(rootPath, sys):
+			sysKey = roots.Key(sys)
+			rel := strings.Trim(sysKey[len(roots.Key(rootPath)):], string(pathSep))
+			sysLevel = strings.Count(rel, string(pathSep)) + 1
+		}
+	}
+
+	t := &tree{nodes: make([]*dirNode, 1, 256)}
+	t.nodes[0] = &dirNode{name: baseName(rootPath)}
+	// Packed into one int rather than a (dev, ino) pair: overlay2 hardlinks
+	// everything, so this set reaches six figures and a struct key costs
+	// several times the bytes of a bare uint64.
+	seenInodes := make(map[uint64]struct{})
+
+	level, next := &frontier{}, &frontier{}
+	level.paths = append([]byte(rootPath), 0)
+	level.dirs = []queued{{end: uint32(len(rootPath)), node: 0, own: true, dedupe: rootDedupe}}
+
+	for depth := 0; len(level.dirs) > 0; depth++ {
+		atSys := depth+1 == sysLevel
+		checkPath := len(w.excluded) > 0 || atSys
+		for _, q := range level.dirs {
+			dirPath := level.path(q)
+			entries, seen, err := w.rd.read(dirPath, q.dedupe)
+			if err != nil {
+				// A directory we cannot read would otherwise silently vanish
+				// from the totals — count it so the UI can say the tree is
+				// incomplete rather than quietly under-reporting.
+				t.nodes[q.node].unreadable++
+				continue
+			}
+			node := t.nodes[q.node]
+			var bytesDone int64
+
+			for i := range entries {
+				e := &entries[i]
+				if !e.dir {
+					if e.key != 0 {
+						if _, dup := seenInodes[e.key]; dup {
+							continue
+						}
+						seenInodes[e.key] = struct{}{}
+					}
+					bytesDone += e.size
+					node.bytes += e.size
+					continue
+				}
+
+				// Don't cross into other filesystems — each root is sized
+				// separately, so we'd otherwise double-count.
+				if e.dev != rootDev {
+					continue
+				}
+				d := q.depth + 1
+				child := next.push(dirPath, e.name, queued{
+					node: q.node, depth: d, dedupe: q.dedupe,
+					own: q.own && int(d) <= w.maxDepth,
+				})
+				if checkPath {
+					key := normKey(next.path(child))
+					if w.excluded[key] {
+						next.pop(child)
+						continue
+					}
+					if atSys && key == sysKey {
+						child.dedupe = true
+					}
+				}
+				if child.own {
+					child.node = int32(len(t.nodes))
+					t.nodes = append(t.nodes, &dirNode{name: string(e.name)})
+					node.children = append(node.children, child.node)
+				}
+				next.dirs[len(next.dirs)-1] = child
+			}
+			w.progress.Add(bytesDone)
+
+			if err := w.pace.wait(ctx, seen); err != nil {
+				return nil, err
+			}
+		}
+		level, next = next, level
+		next.reset()
+	}
+
+	// Breadth-first order puts every child after its parent, so walking it
+	// backwards totals each child before the parent that sums it.
+	for i := len(t.nodes) - 1; i >= 0; i-- {
+		node := t.nodes[i]
+		node.size += node.bytes
+		for _, c := range node.children {
+			node.size += t.nodes[c].size
+			node.unreadable += t.nodes[c].unreadable
+		}
+	}
+	return t, nil
+}
+
+/* ── being a good neighbour ─────────────────────────────────────────────── */
+
+// throttle holds the walk to a fraction of one core. Low priority only
+// matters when something else wants the CPU; on an otherwise quiet box a
+// warm-cache walk would happily pin a core for a minute, which shows up on the
+// very dashboard it is feeding. So after every stretch of work the walk sleeps
+// long enough that the CPU it actually used — measured per thread, so time
+// blocked on the disk costs nothing — averages out to the configured share.
+type throttle struct {
+	share float64 // of one core; >= 1 means unthrottled
+	ops   int
+	mark  time.Time
+	cpu   time.Duration
+	timer *time.Timer
+}
+
+// Enough entries between checks that the CPU-time query is noise, few enough
+// that each sleep is a few milliseconds rather than a visible stall.
+const throttleEvery = 2048
+
+func newThrottle(percent float64) *throttle {
+	t := &throttle{share: percent / 100}
+	if t.share <= 0 {
+		t.share = 1
+	}
+	t.timer = time.NewTimer(time.Hour)
+	t.timer.Stop()
+	t.mark, t.cpu = time.Now(), threadCPU()
+	return t
+}
+
+func (t *throttle) wait(ctx context.Context, ops int) error {
+	if t.ops += ops; t.ops < throttleEvery {
+		return nil
+	}
+	t.ops = 0
+	if t.share < 1 {
+		cpu := threadCPU()
+		idle := time.Duration(float64(cpu-t.cpu)/t.share) - time.Since(t.mark)
+		if idle > time.Millisecond {
+			t.timer.Reset(min(idle, 2*time.Second))
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			case <-t.timer.C:
+			}
+		}
+		t.mark, t.cpu = time.Now(), cpu
+	}
+	// Checked here rather than per entry: off the hot path, but still often
+	// enough to abort a huge walk promptly.
+	return ctx.Err()
+}
+
+/* ── bounded top-N of files ─────────────────────────────────────────────── */
+
+type fileEntry struct {
+	size int64
+	name string
+}
+
+// fileHeap is a min-heap of the topFiles largest files seen, so a new file
+// only has to beat the root to get in. It grows as needed rather than
+// reserving topFiles slots, since most directories hold only a few files.
+type fileHeap []fileEntry
+
+// offer takes the name as bytes so the string is only allocated for a file
+// that actually makes the cut.
+func (h *fileHeap) offer(size int64, name []byte) {
+	if size <= 0 {
+		return
+	}
+	a := *h
+	if len(a) < topFiles {
+		a = append(a, fileEntry{size: size, name: string(name)})
+		for i := len(a) - 1; i > 0; {
+			p := (i - 1) / 2
+			if a[p].size <= a[i].size {
+				break
+			}
+			a[p], a[i] = a[i], a[p]
+			i = p
+		}
+		*h = a
+		return
+	}
+	if size <= a[0].size {
+		return
+	}
+	a[0] = fileEntry{size: size, name: string(name)}
+	for i := 0; ; {
+		l, small := 2*i+1, i
+		if l < len(a) && a[l].size < a[small].size {
+			small = l
+		}
+		if r := l + 1; r < len(a) && a[r].size < a[small].size {
+			small = r
+		}
+		if small == i {
+			break
+		}
+		a[i], a[small] = a[small], a[i]
+		i = small
+	}
+}
+
+/* ── path helpers ───────────────────────────────────────────────────────── */
+
+func baseName(path string) string {
+	for len(path) > 1 && os.IsPathSeparator(path[len(path)-1]) {
+		path = path[:len(path)-1]
+	}
+	for i := len(path) - 1; i >= 0; i-- {
+		if os.IsPathSeparator(path[i]) {
+			if i == len(path)-1 {
+				break
+			}
+			return path[i+1:]
+		}
+	}
+	return path
+}

package/internal/vitals/vitals.go

@@ -0,0 +1,246 @@
+// Package vitals reads host-wide CPU / memory / disk / network figures.
+//
+// On Linux they come straight out of /proc and /sys. Kanshi runs with
+// `network_mode: host` and without lxcfs, so those report real host values
+// with no special configuration. On Windows they come from the same kernel32,
+// ntdll and iphlpapi calls Task Manager uses.
+package vitals
+
+import (
+	"math"
+	"sync"
+	"time"
+
+	"github.com/rene-roid/kanshi/internal/roots"
+)
+
+// Below this gap the counter deltas are too small to divide by: a 20ms window
+// turns a routine 2MB read into a fake 100MB/s spike. Hold the previous rate.
+const minDT = 500 * time.Millisecond
+
+// Reader owns the counter baselines every rate is measured against. One is
+// created per process; the mutex only ever guards against a REST handler
+// sampling at the same moment as the poller.
+type Reader struct {
+	roots *roots.Resolver
+
+	mu       sync.Mutex
+	sys      sysState // the platform's own baselines and cached handles
+	prevNet  counterPair
+	prevDisk counterPair
+	netRate  [2]float64
+	diskRate [2]float64
+}
+
+type counterPair struct {
+	at   time.Time
+	a, b uint64
+	ok   bool
+}
+
+func New(r *roots.Resolver) *Reader { return &Reader{roots: r} }
+
+/* ── payload ────────────────────────────────────────────────────────────── */
+
+// Sample is the JSON the browser consumes; field names are part of the wire
+// contract with web/app.js.
+type Sample struct {
+	TS          float64      `json:"ts"`
+	CPU         CPU          `json:"cpu"`
+	Memory      Memory       `json:"memory"`
+	Swap        Swap         `json:"swap"`
+	Network     RxTx         `json:"network"`
+	DiskIO      ReadWrite    `json:"diskio"`
+	Filesystems []Filesystem `json:"filesystems"`
+	Uptime      float64      `json:"uptime"`
+}
+
+type CPU struct {
+	Percent float64   `json:"percent"`
+	Cores   []float64 `json:"cores"`
+	// Load average and temperature are null where the platform has no such
+	// thing (Windows has no load average) or no readable sensor.
+	Load  *[3]float64 `json:"load"`
+	Count int         `json:"count"`
+	Temp  *float64    `json:"temp"`
+}
+
+type Memory struct {
+	Total     uint64  `json:"total"`
+	Used      uint64  `json:"used"`
+	Available uint64  `json:"available"`
+	Cached    uint64  `json:"cached"`
+	Percent   float64 `json:"percent"`
+}
+
+type Swap struct {
+	Total   uint64  `json:"total"`
+	Used    uint64  `json:"used"`
+	Percent float64 `json:"percent"`
+}
+
+type RxTx struct {
+	RX float64 `json:"rx"`
+	TX float64 `json:"tx"`
+}
+
+type ReadWrite struct {
+	Read  float64 `json:"read"`
+	Write float64 `json:"write"`
+}
+
+type Filesystem struct {
+	Label   string  `json:"label"`
+	Path    string  `json:"path"`
+	Total   uint64  `json:"total"`
+	Used    uint64  `json:"used"`
+	Free    uint64  `json:"free"`
+	Percent float64 `json:"percent"`
+}
+
+/* ── entry points ───────────────────────────────────────────────────────── */
+
+// Prime seeds the counter baselines so the first published frame shows real
+// numbers instead of a screen of zeros.
+func (r *Reader) Prime() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.primeCPU()
+	rx, tx, ok := r.netCounters()
+	rate(&r.prevNet, &r.netRate, rx, tx, ok)
+	read, write, ok := r.diskCounters()
+	rate(&r.prevDisk, &r.diskRate, read, write, ok)
+}
+
+// Sample takes one full reading of the host.
+func (r *Reader) Sample() Sample {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	cores := r.cpuCores()
+	mem, sw := r.memory()
+
+	rx, tx, netOK := r.netCounters()
+	net := rate(&r.prevNet, &r.netRate, rx, tx, netOK)
+	read, write, diskOK := r.diskCounters()
+	disk := rate(&r.prevDisk, &r.diskRate, read, write, diskOK)
+
+	var mean float64
+	if len(cores) > 0 {
+		var sum float64
+		for _, c := range cores {
+			sum += c
+		}
+		mean = round1(sum / float64(len(cores)))
+	}
+	if cores == nil {
+		cores = []float64{} // the browser iterates this; never ship null
+	}
+
+	return Sample{
+		TS: float64(time.Now().UnixNano()) / 1e9,
+		CPU: CPU{
+			Percent: mean,
+			Cores:   cores,
+			Load:    r.loadAvg(),
+			Count:   len(cores),
+			Temp:    r.temperature(),
+		},
+		Memory:      mem,
+		Swap:        sw,
+		Network:     RxTx{RX: net[0], TX: net[1]},
+		DiskIO:      ReadWrite{Read: disk[0], Write: disk[1]},
+		Filesystems: r.Filesystems(),
+		Uptime:      r.uptime(),
+	}
+}
+
+// Filesystems reports usage for each storage root's volume. Roots that share a
+// volume — C:\ and the profile folder on it — get one meter, labelled with the
+// first of them.
+func (r *Reader) Filesystems() []Filesystem {
+	list := r.roots.Roots()
+	out := make([]Filesystem, 0, len(list))
+	seen := make(map[string]bool, len(list))
+	for _, root := range list {
+		u, err := roots.DiskUsage(root.Path)
+		if err != nil || u.Total == 0 || seen[u.Volume] {
+			continue
+		}
+		seen[u.Volume] = true
+		fs := Filesystem{Label: root.Label, Path: root.Path, Total: u.Total, Used: u.Used, Free: u.Free}
+		if u.Used+u.Free > 0 {
+			fs.Percent = round1(float64(u.Used) / float64(u.Used+u.Free) * 100)
+		}
+		out = append(out, fs)
+	}
+	return out
+}
+
+/* ── shared arithmetic ──────────────────────────────────────────────────── */
+
+// busyPercent turns two counter deltas into a utilisation, clamped to 0–100.
+func busyPercent(busyDelta, allDelta float64) float64 {
+	if allDelta <= 0 || busyDelta <= 0 {
+		return 0
+	}
+	return round1(math.Min(busyDelta/allDelta*100, 100))
+}
+
+func memoryFigures(total, avail, cached uint64) Memory {
+	if avail > total {
+		avail = total
+	}
+	used := total - avail
+	m := Memory{Total: total, Used: used, Available: avail, Cached: cached}
+	if total > 0 {
+		m.Percent = round1(float64(used) / float64(total) * 100)
+	}
+	return m
+}
+
+func swapFigures(total, free uint64) Swap {
+	if free > total {
+		free = total
+	}
+	s := Swap{Total: total, Used: total - free}
+	if total > 0 {
+		s.Percent = round1(float64(s.Used) / float64(total) * 100)
+	}
+	return s
+}
+
+// rate turns two counter readings into bytes/second, holding the previous
+// answer when the window is too short to divide by.
+func rate(prev *counterPair, held *[2]float64, a, b uint64, ok bool) [2]float64 {
+	if !ok {
+		return [2]float64{0, 0}
+	}
+	now := time.Now()
+	if prev.ok && now.Sub(prev.at) < minDT {
+		return *held
+	}
+	was := *prev
+	*prev = counterPair{at: now, a: a, b: b, ok: true}
+	if !was.ok {
+		return [2]float64{0, 0}
+	}
+	dt := now.Sub(was.at).Seconds()
+	if dt <= 0 {
+		return *held
+	}
+	// Counters are 64-bit but reset when an interface or disk disappears;
+	// clamp rather than reporting a negative or an absurd spike.
+	*held = [2]float64{diff(a, was.a) / dt, diff(b, was.b) / dt}
+	return *held
+}
+
+func diff(now, prev uint64) float64 {
+	if now < prev {
+		return 0
+	}
+	return float64(now - prev)
+}
+
+func round1(v float64) float64 { return math.Round(v*10) / 10 }
+func round2(v float64) float64 { return math.Round(v*100) / 100 }