261 lines
6.7 KiB
Go
261 lines
6.7 KiB
Go
package config
|
||
|
||
import (
|
||
"fmt"
|
||
"os"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"gopkg.in/yaml.v3"
|
||
)
|
||
|
||
type Config struct {
|
||
Global GlobalConfig `yaml:"global"`
|
||
Alerts []AlertConfig `yaml:"alerts"`
|
||
Monitors []MonitorConfig `yaml:"monitors"`
|
||
Dashboard DashboardConfig `yaml:"dashboard"`
|
||
}
|
||
|
||
type GlobalConfig struct {
|
||
CheckInterval int `yaml:"check_interval"` // seconds
|
||
Timeout int `yaml:"timeout"` // seconds
|
||
AlertCooldown int `yaml:"alert_cooldown"` // seconds
|
||
RetentionDays int `yaml:"retention_days"` // 0 = keep forever
|
||
LogFormat string `yaml:"log_format"` // "text" (default) | "json"
|
||
}
|
||
|
||
// StringSlice accepts either a single YAML string or a YAML sequence.
|
||
type StringSlice []string
|
||
|
||
func (s *StringSlice) UnmarshalYAML(value *yaml.Node) error {
|
||
if value.Kind == yaml.ScalarNode {
|
||
*s = StringSlice{value.Value}
|
||
return nil
|
||
}
|
||
var strs []string
|
||
if err := value.Decode(&strs); err != nil {
|
||
return err
|
||
}
|
||
*s = strs
|
||
return nil
|
||
}
|
||
|
||
type AlertConfig struct {
|
||
Name string `yaml:"name"` // optional; used for per-monitor routing
|
||
Type string `yaml:"type"` // "discord" | "slack" | "email" | "ntfy" | "gotify"
|
||
WebhookURL string `yaml:"webhook_url"` // discord / slack
|
||
SMTPHost string `yaml:"smtp_host"`
|
||
SMTPPort int `yaml:"smtp_port"`
|
||
From string `yaml:"from"`
|
||
To StringSlice `yaml:"to"` // one or more email addresses
|
||
Username string `yaml:"username"`
|
||
Password string `yaml:"password"`
|
||
URL string `yaml:"url"` // ntfy topic URL or gotify server base URL
|
||
Token string `yaml:"token"` // ntfy bearer token or gotify app token
|
||
Priority int `yaml:"priority"` // gotify priority; default 5
|
||
}
|
||
|
||
// MaintenanceWindow suppresses alerts during a recurring time range.
|
||
type MaintenanceWindow struct {
|
||
Days []string `yaml:"days"` // abbreviated weekday names ("mon"…"sun"), or "*" for all
|
||
Start string `yaml:"start"` // "HH:MM" in server local time
|
||
End string `yaml:"end"` // "HH:MM"
|
||
}
|
||
|
||
// Active reports whether the window covers t.
|
||
func (w *MaintenanceWindow) Active(t time.Time) bool {
|
||
if len(w.Days) > 0 {
|
||
day := strings.ToLower(t.Weekday().String()[:3])
|
||
found := false
|
||
for _, d := range w.Days {
|
||
if d == "*" || strings.ToLower(d) == day {
|
||
found = true
|
||
break
|
||
}
|
||
}
|
||
if !found {
|
||
return false
|
||
}
|
||
}
|
||
startH, startM, err1 := parseHHMM(w.Start)
|
||
endH, endM, err2 := parseHHMM(w.End)
|
||
if err1 != nil || err2 != nil {
|
||
return false
|
||
}
|
||
now := t.Hour()*60 + t.Minute()
|
||
start := startH*60 + startM
|
||
end := endH*60 + endM
|
||
if start <= end {
|
||
return now >= start && now < end
|
||
}
|
||
// Crosses midnight (e.g. 23:00–02:00)
|
||
return now >= start || now < end
|
||
}
|
||
|
||
func parseHHMM(s string) (int, int, error) {
|
||
parts := strings.SplitN(s, ":", 2)
|
||
if len(parts) != 2 {
|
||
return 0, 0, fmt.Errorf("invalid time %q", s)
|
||
}
|
||
h, err := strconv.Atoi(parts[0])
|
||
if err != nil {
|
||
return 0, 0, err
|
||
}
|
||
m, err := strconv.Atoi(parts[1])
|
||
if err != nil {
|
||
return 0, 0, err
|
||
}
|
||
return h, m, nil
|
||
}
|
||
|
||
type MonitorConfig struct {
|
||
Name string `yaml:"name"`
|
||
Type string `yaml:"type"` // "http" | "tcp" | "tls" | "dns"
|
||
|
||
// HTTP
|
||
URL string `yaml:"url"`
|
||
Method string `yaml:"method"` // default "GET"
|
||
Body string `yaml:"body"`
|
||
Headers map[string]string `yaml:"headers"`
|
||
ExpectedStatus int `yaml:"expected_status"` // default 200
|
||
Contains string `yaml:"contains"`
|
||
|
||
// TCP / TLS / DNS
|
||
Host string `yaml:"host"`
|
||
Port int `yaml:"port"`
|
||
|
||
// TLS
|
||
ExpiryWarningDays int `yaml:"expiry_warning_days"` // default 14
|
||
|
||
// DNS
|
||
ExpectedIP string `yaml:"expected_ip"` // optional; assert resolved IPs include this
|
||
|
||
// Thresholds
|
||
MaxResponseMS int64 `yaml:"max_response_ms"` // 0 = no threshold
|
||
|
||
// Per-monitor scheduling
|
||
Interval int `yaml:"interval"` // seconds; 0 = global default
|
||
Timeout int `yaml:"timeout"` // seconds; 0 = global default
|
||
|
||
// Alerting
|
||
AlertNames []string `yaml:"alert_names"` // empty = all alerters
|
||
Maintenance []MaintenanceWindow `yaml:"maintenance"`
|
||
}
|
||
|
||
type DashboardConfig struct {
|
||
Enabled bool `yaml:"enabled"`
|
||
Listen string `yaml:"listen"`
|
||
Username string `yaml:"username"`
|
||
Password string `yaml:"password"`
|
||
}
|
||
|
||
func Load(path string) (*Config, error) {
|
||
data, err := os.ReadFile(path)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read config: %w", err)
|
||
}
|
||
var cfg Config
|
||
if err := yaml.Unmarshal(data, &cfg); err != nil {
|
||
return nil, fmt.Errorf("parse config: %w", err)
|
||
}
|
||
applyDefaults(&cfg)
|
||
if err := validate(&cfg); err != nil {
|
||
return nil, err
|
||
}
|
||
return &cfg, nil
|
||
}
|
||
|
||
func applyDefaults(cfg *Config) {
|
||
if cfg.Global.CheckInterval == 0 {
|
||
cfg.Global.CheckInterval = 60
|
||
}
|
||
if cfg.Global.Timeout == 0 {
|
||
cfg.Global.Timeout = 10
|
||
}
|
||
if cfg.Global.AlertCooldown == 0 {
|
||
cfg.Global.AlertCooldown = 300
|
||
}
|
||
if cfg.Global.LogFormat == "" {
|
||
cfg.Global.LogFormat = "text"
|
||
}
|
||
if cfg.Dashboard.Listen == "" {
|
||
cfg.Dashboard.Listen = ":8081"
|
||
}
|
||
for i := range cfg.Monitors {
|
||
m := &cfg.Monitors[i]
|
||
if m.Type == "http" {
|
||
if m.ExpectedStatus == 0 {
|
||
m.ExpectedStatus = 200
|
||
}
|
||
if m.Method == "" {
|
||
m.Method = "GET"
|
||
}
|
||
}
|
||
if m.Type == "tls" {
|
||
if m.ExpiryWarningDays == 0 {
|
||
m.ExpiryWarningDays = 14
|
||
}
|
||
if m.Port == 0 {
|
||
m.Port = 443
|
||
}
|
||
}
|
||
if m.Interval == 0 {
|
||
m.Interval = cfg.Global.CheckInterval
|
||
}
|
||
if m.Timeout == 0 {
|
||
m.Timeout = cfg.Global.Timeout
|
||
}
|
||
}
|
||
for i := range cfg.Alerts {
|
||
if cfg.Alerts[i].Type == "gotify" && cfg.Alerts[i].Priority == 0 {
|
||
cfg.Alerts[i].Priority = 5
|
||
}
|
||
}
|
||
}
|
||
|
||
func validate(cfg *Config) error {
|
||
names := make(map[string]bool)
|
||
for _, m := range cfg.Monitors {
|
||
if m.Name == "" {
|
||
return fmt.Errorf("monitor missing name")
|
||
}
|
||
if names[m.Name] {
|
||
return fmt.Errorf("duplicate monitor name: %q", m.Name)
|
||
}
|
||
names[m.Name] = true
|
||
switch m.Type {
|
||
case "http":
|
||
if m.URL == "" {
|
||
return fmt.Errorf("monitor %q: missing url", m.Name)
|
||
}
|
||
case "tcp", "tls":
|
||
if m.Host == "" || m.Port == 0 {
|
||
return fmt.Errorf("monitor %q: missing host or port", m.Name)
|
||
}
|
||
case "dns":
|
||
if m.Host == "" {
|
||
return fmt.Errorf("monitor %q: missing host", m.Name)
|
||
}
|
||
default:
|
||
return fmt.Errorf("monitor %q: unknown type %q", m.Name, m.Type)
|
||
}
|
||
}
|
||
|
||
// Build set of named alerters to validate monitor alert_names references.
|
||
alertNames := make(map[string]bool)
|
||
for _, a := range cfg.Alerts {
|
||
if a.Name != "" {
|
||
alertNames[a.Name] = true
|
||
}
|
||
}
|
||
for _, m := range cfg.Monitors {
|
||
for _, an := range m.AlertNames {
|
||
if !alertNames[an] {
|
||
return fmt.Errorf("monitor %q: alert_name %q not defined", m.Name, an)
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|