Mitchell-JohnsonandClaude Fable 5.1
b05a053920
- sensors:read tokens open the sensor endpoints (here and on managed machines through the hub) and nothing else; full tokens are never accepted from a URL - /api/sensors/stream: a shaped query that keeps answering, over SSE - /metrics: Prometheus text format - services, updates, ZFS and SMART as background status sensors - widget library over the sensor API; custom widgets on the dashboard - /embed/widget: one live widget in its own bundle, the only frameable path - Dashboard tab is now Monitors Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
123 lines
3.2 KiB
Go
123 lines
3.2 KiB
Go
// Package config loads and saves hamlab's JSON config file.
|
|
package config
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"time"
|
|
|
|
"hamlab/internal/store"
|
|
)
|
|
|
|
// Token is an API token another Ham Lab (a hub) uses to manage this host. Only the
|
|
// SHA-256 of the token is kept.
|
|
type Token struct {
|
|
Name string `json:"name"`
|
|
Hash string `json:"hash"`
|
|
Created time.Time `json:"created"`
|
|
// Scope is what the token may do. "" is everything (a hub's token: full control of
|
|
// this machine). ScopeSensorsRead only reads sensors — what a dashboard gets.
|
|
Scope string `json:"scope,omitempty"`
|
|
}
|
|
|
|
const ScopeSensorsRead = "sensors:read"
|
|
|
|
// Node is a remote Ham Lab this host (as hub) manages. The token is the one that
|
|
// node issued to us; the fingerprint pins its self-signed certificate.
|
|
type Node struct {
|
|
Name string `json:"name"`
|
|
URL string `json:"url"`
|
|
Fingerprint string `json:"fingerprint,omitempty"`
|
|
Token string `json:"token"`
|
|
Added time.Time `json:"added"`
|
|
}
|
|
|
|
type Config struct {
|
|
Listen string `json:"listen"`
|
|
PasswordHash string `json:"password_hash"`
|
|
TLS string `json:"tls,omitempty"` // "auto" → self-signed cert in the data dir; "" → plain HTTP
|
|
Tokens []Token `json:"tokens,omitempty"`
|
|
Nodes []Node `json:"nodes,omitempty"`
|
|
|
|
path string
|
|
mu sync.Mutex
|
|
}
|
|
|
|
// Candidates lists where config.json may live under a home directory, preferred first:
|
|
// the XDG location, then ~/apps/hamlab, which installs before v0.2 used.
|
|
func Candidates(home string) []string {
|
|
return []string{filepath.Join(home, ".config", "hamlab", "config.json"), filepath.Join(home, "apps", "hamlab", "config.json")}
|
|
}
|
|
|
|
// DefaultPath is the config used when neither -config nor $HAMLAB_CONFIG says otherwise:
|
|
// whichever candidate exists, else the preferred one.
|
|
func DefaultPath() string {
|
|
home, _ := os.UserHomeDir()
|
|
c := Candidates(home)
|
|
for _, p := range c {
|
|
if _, err := os.Stat(p); err == nil {
|
|
return p
|
|
}
|
|
}
|
|
return c[0]
|
|
}
|
|
|
|
func Default(path string) *Config {
|
|
return &Config{Listen: "127.0.0.1:8100", path: path}
|
|
}
|
|
|
|
// Load reads the config at path. A missing file yields the defaults.
|
|
func Load(path string) (*Config, error) {
|
|
c := Default(path)
|
|
b, err := os.ReadFile(path)
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return c, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := json.Unmarshal(b, c); err != nil {
|
|
return nil, fmt.Errorf("parse %s: %w", path, err)
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
func (c *Config) Path() string { return c.path }
|
|
func (c *Config) DataDir() string { return filepath.Dir(c.path) }
|
|
|
|
func (c *Config) Save() error {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
return c.save()
|
|
}
|
|
|
|
func (c *Config) save() error {
|
|
if err := os.MkdirAll(c.DataDir(), 0o700); err != nil {
|
|
return err
|
|
}
|
|
b, err := json.MarshalIndent(c, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return store.WriteFileAtomic(c.path, append(b, '\n'), 0o600)
|
|
}
|
|
|
|
// Update applies fn under the lock and saves.
|
|
func (c *Config) Update(fn func(*Config)) error {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
fn(c)
|
|
return c.save()
|
|
}
|
|
|
|
// View reads under the lock.
|
|
func (c *Config) View(fn func(*Config)) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
fn(c)
|
|
}
|