289 lines
8.6 KiB
Go
289 lines
8.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"connectrpc.com/connect"
|
|
"github.com/labstack/echo/v4"
|
|
"github.com/labstack/echo/v4/middleware"
|
|
"gopkg.in/yaml.v3"
|
|
homelabv1 "pwa-homelab-mon/gen/homelab/v1"
|
|
"pwa-homelab-mon/gen/homelab/v1/homelabv1connect"
|
|
)
|
|
|
|
// --- config ---
|
|
|
|
type Item struct {
|
|
Name string `yaml:"name"`
|
|
Script string `yaml:"script"`
|
|
Refresh int `yaml:"refresh"` // monitor: seconds
|
|
Data string `yaml:"data"` // monitor: text | percentage
|
|
Args int `yaml:"args"` // exec: arg count
|
|
ArgTypes []string `yaml:"arg_types"` // exec: text | number per arg
|
|
}
|
|
|
|
type Link struct {
|
|
Name string `yaml:"name"`
|
|
URL string `yaml:"url"`
|
|
}
|
|
|
|
type Config struct {
|
|
Links []Link `yaml:"links"`
|
|
Monitor []Item `yaml:"monitor"`
|
|
Exec []Item `yaml:"exec"`
|
|
}
|
|
|
|
func loadConfig(path string) (*Config, error) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
var cfg Config
|
|
dec := yaml.NewDecoder(f)
|
|
dec.KnownFields(true)
|
|
if err := dec.Decode(&cfg); err != nil {
|
|
return nil, fmt.Errorf("parse %s: %w", path, err)
|
|
}
|
|
for _, it := range cfg.Monitor {
|
|
if it.Refresh <= 0 {
|
|
return nil, fmt.Errorf("monitor %q: refresh must be > 0", it.Name)
|
|
}
|
|
if it.Data != "text" && it.Data != "percentage" {
|
|
return nil, fmt.Errorf("monitor %q: data must be text|percentage", it.Name)
|
|
}
|
|
}
|
|
for _, it := range cfg.Exec {
|
|
if len(it.ArgTypes) != it.Args {
|
|
return nil, fmt.Errorf("exec %q: arg_types must have args entries", it.Name)
|
|
}
|
|
for _, t := range it.ArgTypes {
|
|
if t != "text" && t != "number" {
|
|
return nil, fmt.Errorf("exec %q: arg type must be text|number", it.Name)
|
|
}
|
|
}
|
|
}
|
|
return &cfg, nil
|
|
}
|
|
|
|
// --- service ---
|
|
|
|
type server struct {
|
|
cfg *Config
|
|
exec map[string]*Item // by item name, read-only after start
|
|
monVals sync.Map // monitor item name -> string (last output)
|
|
docsDir string
|
|
}
|
|
|
|
const execTimeout = 10 * time.Second
|
|
|
|
func runScript(s *Item, args ...string) (string, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), execTimeout)
|
|
defer cancel()
|
|
out, err := exec.CommandContext(ctx, s.Script, args...).CombinedOutput()
|
|
if err != nil {
|
|
return "", fmt.Errorf("%v: %s", err, out)
|
|
}
|
|
return string(out), nil
|
|
}
|
|
|
|
func (s *server) startMonitors() {
|
|
for i := range s.cfg.Monitor {
|
|
sc := &s.cfg.Monitor[i]
|
|
log.Printf("monitor started: %s (%s) every %ds", sc.Name, sc.Script, sc.Refresh)
|
|
go func(sc *Item) {
|
|
for {
|
|
v, err := runScript(sc)
|
|
if err != nil {
|
|
log.Printf("monitor %s: %v", sc.Name, err)
|
|
v = "error: " + err.Error()
|
|
} else {
|
|
log.Printf("monitor %s -> %s", sc.Name, strings.TrimSpace(v))
|
|
}
|
|
s.monVals.Store(sc.Name, v)
|
|
time.Sleep(time.Duration(sc.Refresh) * time.Second)
|
|
}
|
|
}(sc)
|
|
}
|
|
}
|
|
|
|
// --- docs ---
|
|
|
|
func docHash(b []byte) string {
|
|
h := sha256.Sum256(b)
|
|
return hex.EncodeToString(h[:])
|
|
}
|
|
|
|
// docPath resolves a doc name safely: plain file name only, no separators, always inside docsDir.
|
|
func (s *server) docPath(name string) (string, error) {
|
|
if filepath.Base(name) != name || filepath.Ext(name) != ".md" {
|
|
return "", fmt.Errorf("bad doc name %q", name)
|
|
}
|
|
p := filepath.Join(s.docsDir, name)
|
|
if filepath.Dir(p) != s.docsDir {
|
|
return "", fmt.Errorf("bad doc name %q", name)
|
|
}
|
|
return p, nil
|
|
}
|
|
|
|
func (s *server) ListDocs(context.Context, *connect.Request[homelabv1.ListDocsRequest]) (*connect.Response[homelabv1.ListDocsResponse], error) {
|
|
resp := &homelabv1.ListDocsResponse{}
|
|
entries, err := os.ReadDir(s.docsDir)
|
|
if err != nil {
|
|
return connect.NewResponse(resp), nil // no docs dir = no docs
|
|
}
|
|
for _, e := range entries {
|
|
if e.IsDir() || !strings.HasSuffix(e.Name(), ".md") {
|
|
continue
|
|
}
|
|
b, err := os.ReadFile(filepath.Join(s.docsDir, e.Name()))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
resp.Docs = append(resp.Docs, &homelabv1.DocMeta{Name: e.Name(), Hash: docHash(b)})
|
|
}
|
|
return connect.NewResponse(resp), nil
|
|
}
|
|
|
|
func (s *server) GetDoc(_ context.Context, req *connect.Request[homelabv1.GetDocRequest]) (*connect.Response[homelabv1.GetDocResponse], error) {
|
|
p, err := s.docPath(req.Msg.GetName())
|
|
if err != nil {
|
|
return nil, connect.NewError(connect.CodeInvalidArgument, err)
|
|
}
|
|
b, err := os.ReadFile(p)
|
|
if err != nil {
|
|
return nil, connect.NewError(connect.CodeNotFound, err)
|
|
}
|
|
return connect.NewResponse(&homelabv1.GetDocResponse{Content: string(b)}), nil
|
|
}
|
|
|
|
func (s *server) SaveDoc(_ context.Context, req *connect.Request[homelabv1.SaveDocRequest]) (*connect.Response[homelabv1.SaveDocResponse], error) {
|
|
p, err := s.docPath(req.Msg.GetName())
|
|
if err != nil {
|
|
return nil, connect.NewError(connect.CodeInvalidArgument, err)
|
|
}
|
|
content := []byte(req.Msg.GetContent())
|
|
// ponytail: client authority — last write wins, no base-hash check; add optimistic locking if concurrent edits appear
|
|
if err := os.WriteFile(p, content, 0o644); err != nil {
|
|
return nil, connect.NewError(connect.CodeInternal, err)
|
|
}
|
|
log.Printf("doc saved: %s (%d bytes)", filepath.Base(p), len(content))
|
|
return connect.NewResponse(&homelabv1.SaveDocResponse{Hash: docHash(content)}), nil
|
|
}
|
|
|
|
// --- content RPC ---
|
|
|
|
func (s *server) ListContent(context.Context, *connect.Request[homelabv1.ListContentRequest]) (*connect.Response[homelabv1.ListContentResponse], error) {
|
|
resp := &homelabv1.ListContentResponse{}
|
|
for _, l := range s.cfg.Links {
|
|
resp.Links = append(resp.Links, &homelabv1.Link{Name: l.Name, Url: l.URL})
|
|
}
|
|
for i := range s.cfg.Monitor {
|
|
it := &s.cfg.Monitor[i]
|
|
val, _ := s.monVals.Load(it.Name)
|
|
v, _ := val.(string)
|
|
resp.Monitors = append(resp.Monitors, &homelabv1.Item{Name: it.Name, Data: it.Data, Value: v})
|
|
}
|
|
for i := range s.cfg.Exec {
|
|
it := &s.cfg.Exec[i]
|
|
resp.Exec = append(resp.Exec, &homelabv1.Item{Name: it.Name, Args: int32(it.Args), ArgTypes: it.ArgTypes})
|
|
}
|
|
return connect.NewResponse(resp), nil
|
|
}
|
|
|
|
func (s *server) RunScript(_ context.Context, req *connect.Request[homelabv1.RunScriptRequest]) (*connect.Response[homelabv1.RunScriptResponse], error) {
|
|
it, ok := s.exec[req.Msg.GetName()]
|
|
if !ok {
|
|
return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("no exec item %q", req.Msg.GetName()))
|
|
}
|
|
if len(req.Msg.GetArgs()) != it.Args {
|
|
return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("%q takes %d args, got %d", it.Name, it.Args, len(req.Msg.GetArgs())))
|
|
}
|
|
out, err := runScript(it, req.Msg.GetArgs()...)
|
|
if err != nil {
|
|
log.Printf("script %s args=%v: ERROR %v", it.Name, req.Msg.GetArgs(), err)
|
|
return nil, connect.NewError(connect.CodeInternal, err)
|
|
}
|
|
log.Printf("script %s args=%v -> %s", it.Name, req.Msg.GetArgs(), strings.TrimSpace(out))
|
|
return connect.NewResponse(&homelabv1.RunScriptResponse{Output: out}), nil
|
|
}
|
|
|
|
// --- main ---
|
|
|
|
func main() {
|
|
cfgPath := os.Getenv("CONFIG")
|
|
if cfgPath == "" {
|
|
cfgPath = "config.yaml"
|
|
}
|
|
cfg, err := loadConfig(cfgPath)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "config:", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
docsDir := "docs"
|
|
if err := os.MkdirAll(docsDir, 0o755); err != nil {
|
|
fmt.Fprintln(os.Stderr, "docs:", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
svc := &server{cfg: cfg, exec: map[string]*Item{}, docsDir: docsDir}
|
|
for i := range cfg.Exec {
|
|
svc.exec[cfg.Exec[i].Name] = &cfg.Exec[i]
|
|
}
|
|
svc.startMonitors()
|
|
|
|
log.Printf("config %s: %d links, %d monitors, %d exec", cfgPath, len(cfg.Links), len(cfg.Monitor), len(cfg.Exec))
|
|
|
|
e := echo.New()
|
|
e.HideBanner = true
|
|
// HTTP request log, except the ListContent heartbeat (every 3s per client — pure noise).
|
|
e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{
|
|
Skipper: func(c echo.Context) bool {
|
|
return c.Request().URL.Path == "/homelab.v1.HomelabService/ListContent"
|
|
},
|
|
}))
|
|
|
|
// ConnectRPC handler on the mux (matches /homelab.v1.HomelabService/<Method>).
|
|
mux := http.NewServeMux()
|
|
mux.Handle(homelabv1connect.NewHomelabServiceHandler(svc))
|
|
e.Any("/homelab.v1.HomelabService/*", echo.WrapHandler(mux))
|
|
|
|
// sw.js and index.html must never be cached: stale index = stale asset references = iOS never updates.
|
|
e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
|
|
return func(c echo.Context) error {
|
|
p := c.Request().URL.Path
|
|
if p == "/sw.js" || p == "/manifest.webmanifest" || p == "/index.html" || p == "/" {
|
|
c.Response().Header().Set("Cache-Control", "no-cache")
|
|
}
|
|
return next(c)
|
|
}
|
|
})
|
|
|
|
// Static PWA from dist/ (built by make web); HTML5 mode falls back to index.html for SPA routes.
|
|
e.Use(middleware.StaticWithConfig(middleware.StaticConfig{
|
|
Root: "dist",
|
|
HTML5: true,
|
|
}))
|
|
|
|
e.Logger.Fatal(e.Start(port()))
|
|
}
|
|
|
|
func port() string {
|
|
if p := os.Getenv("PORT"); p != "" {
|
|
return ":" + p
|
|
}
|
|
return ":8080"
|
|
}
|