feat: initial commit — uptime monitor (forked from go-upkeep)
Go-based uptime monitor with SQLite/Postgres storage, TUI dashboard, SSH server, alerting, and clustering support.
This commit is contained in:
@@ -0,0 +1,84 @@
|
||||
package alert
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"go-upkeep/internal/models"
|
||||
"net/http"
|
||||
"net/smtp"
|
||||
)
|
||||
|
||||
type Provider interface {
|
||||
Send(title, message string) error
|
||||
}
|
||||
|
||||
func GetProvider(cfg models.AlertConfig) Provider {
|
||||
switch cfg.Type {
|
||||
case "discord":
|
||||
return &DiscordProvider{URL: cfg.Settings["url"]}
|
||||
case "slack":
|
||||
return &SlackProvider{URL: cfg.Settings["url"]}
|
||||
case "webhook":
|
||||
// Generic Webhook
|
||||
return &WebhookProvider{URL: cfg.Settings["url"]}
|
||||
case "email":
|
||||
port := "25"
|
||||
if p, ok := cfg.Settings["port"]; ok { port = p }
|
||||
return &EmailProvider{
|
||||
Host: cfg.Settings["host"],
|
||||
Port: port,
|
||||
User: cfg.Settings["user"],
|
||||
Pass: cfg.Settings["pass"],
|
||||
To: cfg.Settings["to"],
|
||||
From: cfg.Settings["from"],
|
||||
}
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// --- DISCORD ---
|
||||
type DiscordProvider struct{ URL string }
|
||||
func (d *DiscordProvider) Send(title, message string) error {
|
||||
payload := map[string]string{"content": fmt.Sprintf("**%s**\n%s", title, message)}
|
||||
jsonValue, _ := json.Marshal(payload)
|
||||
_, err := http.Post(d.URL, "application/json", bytes.NewBuffer(jsonValue))
|
||||
return err
|
||||
}
|
||||
|
||||
// --- SLACK ---
|
||||
type SlackProvider struct{ URL string }
|
||||
func (s *SlackProvider) Send(title, message string) error {
|
||||
payload := map[string]string{"text": fmt.Sprintf("*%s*\n%s", title, message)}
|
||||
jsonValue, _ := json.Marshal(payload)
|
||||
_, err := http.Post(s.URL, "application/json", bytes.NewBuffer(jsonValue))
|
||||
return err
|
||||
}
|
||||
|
||||
// --- GENERIC WEBHOOK ---
|
||||
type WebhookProvider struct{ URL string }
|
||||
func (w *WebhookProvider) Send(title, message string) error {
|
||||
// Sends a standard JSON payload
|
||||
payload := map[string]string{
|
||||
"title": title,
|
||||
"message": message,
|
||||
"status": "alert",
|
||||
}
|
||||
jsonValue, _ := json.Marshal(payload)
|
||||
_, err := http.Post(w.URL, "application/json", bytes.NewBuffer(jsonValue))
|
||||
return err
|
||||
}
|
||||
|
||||
// --- EMAIL ---
|
||||
type EmailProvider struct {
|
||||
Host, Port, User, Pass, To, From string
|
||||
}
|
||||
func (e *EmailProvider) Send(title, message string) error {
|
||||
auth := smtp.PlainAuth("", e.User, e.Pass, e.Host)
|
||||
msg := []byte("To: " + e.To + "\r\n" +
|
||||
"Subject: Go-Upkeep: " + title + "\r\n" +
|
||||
"\r\n" +
|
||||
message + "\r\n")
|
||||
return smtp.SendMail(e.Host+":"+e.Port, auth, e.From, []string{e.To}, msg)
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
package cluster
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"go-upkeep/internal/monitor"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
Mode string // "leader" or "follower"
|
||||
PeerURL string // URL of the Leader (e.g., http://primary:8080)
|
||||
SharedKey string // Security Key
|
||||
}
|
||||
|
||||
func Start(cfg Config) {
|
||||
if cfg.Mode == "leader" {
|
||||
fmt.Println("Cluster: Running as LEADER (Active)")
|
||||
monitor.SetEngineActive(true)
|
||||
return
|
||||
}
|
||||
|
||||
if cfg.Mode == "follower" {
|
||||
fmt.Println("Cluster: Running as FOLLOWER (Passive)")
|
||||
monitor.SetEngineActive(false) // Start passive
|
||||
go runFollowerLoop(cfg)
|
||||
}
|
||||
}
|
||||
|
||||
func runFollowerLoop(cfg Config) {
|
||||
client := http.Client{Timeout: 2 * time.Second}
|
||||
|
||||
// Failover Configuration
|
||||
failures := 0
|
||||
threshold := 3
|
||||
|
||||
for {
|
||||
time.Sleep(5 * time.Second)
|
||||
|
||||
req, _ := http.NewRequest("GET", cfg.PeerURL+"/api/health", nil)
|
||||
if cfg.SharedKey != "" {
|
||||
req.Header.Set("X-Upkeep-Secret", cfg.SharedKey)
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
isLeaderHealthy := false
|
||||
|
||||
if err == nil && resp.StatusCode == 200 {
|
||||
isLeaderHealthy = true
|
||||
resp.Body.Close()
|
||||
}
|
||||
|
||||
if isLeaderHealthy {
|
||||
failures = 0
|
||||
if monitor.IsEngineActive() {
|
||||
// Leader is back, yield
|
||||
monitor.SetEngineActive(false)
|
||||
monitor.AddLog("Cluster: Leader detected. Switching to PASSIVE.")
|
||||
}
|
||||
} else {
|
||||
failures++
|
||||
// If failures exceed threshold, take over
|
||||
if failures >= threshold && !monitor.IsEngineActive() {
|
||||
monitor.SetEngineActive(true)
|
||||
monitor.AddLog("Cluster: Leader Unreachable. Switching to ACTIVE.")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package models
|
||||
|
||||
import "time"
|
||||
|
||||
type Site struct {
|
||||
ID int
|
||||
Name string
|
||||
URL string
|
||||
Type string // "http" or "push"
|
||||
Token string // Secure Token
|
||||
Interval int
|
||||
AlertID int
|
||||
CheckSSL bool
|
||||
ExpiryThreshold int
|
||||
|
||||
MaxRetries int
|
||||
FailureCount int
|
||||
|
||||
Status string
|
||||
StatusCode int
|
||||
Latency time.Duration
|
||||
CertExpiry time.Time
|
||||
HasSSL bool
|
||||
LastCheck time.Time
|
||||
SentSSLWarning bool
|
||||
}
|
||||
|
||||
type AlertConfig struct {
|
||||
ID int
|
||||
Name string
|
||||
Type string
|
||||
Settings map[string]string
|
||||
}
|
||||
|
||||
type User struct {
|
||||
ID int
|
||||
Username string
|
||||
PublicKey string
|
||||
Role string
|
||||
}
|
||||
|
||||
// Phase 5: Backup Structure
|
||||
type Backup struct {
|
||||
Sites []Site `json:"sites"`
|
||||
Alerts []AlertConfig `json:"alerts"`
|
||||
Users []User `json:"users"`
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package monitor
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const maxHistoryLen = 30
|
||||
|
||||
type SiteHistory struct {
|
||||
Latencies []time.Duration
|
||||
Statuses []bool
|
||||
TotalChecks int
|
||||
UpChecks int
|
||||
}
|
||||
|
||||
var (
|
||||
histories = make(map[int]*SiteHistory)
|
||||
historyMu sync.RWMutex
|
||||
)
|
||||
|
||||
func RecordCheck(siteID int, latency time.Duration, isUp bool) {
|
||||
historyMu.Lock()
|
||||
defer historyMu.Unlock()
|
||||
|
||||
h, ok := histories[siteID]
|
||||
if !ok {
|
||||
h = &SiteHistory{}
|
||||
histories[siteID] = h
|
||||
}
|
||||
|
||||
h.TotalChecks++
|
||||
if isUp {
|
||||
h.UpChecks++
|
||||
}
|
||||
|
||||
h.Latencies = append(h.Latencies, latency)
|
||||
if len(h.Latencies) > maxHistoryLen {
|
||||
h.Latencies = h.Latencies[len(h.Latencies)-maxHistoryLen:]
|
||||
}
|
||||
|
||||
h.Statuses = append(h.Statuses, isUp)
|
||||
if len(h.Statuses) > maxHistoryLen {
|
||||
h.Statuses = h.Statuses[len(h.Statuses)-maxHistoryLen:]
|
||||
}
|
||||
}
|
||||
|
||||
func GetHistory(siteID int) (SiteHistory, bool) {
|
||||
historyMu.RLock()
|
||||
defer historyMu.RUnlock()
|
||||
h, ok := histories[siteID]
|
||||
if !ok {
|
||||
return SiteHistory{}, false
|
||||
}
|
||||
cp := SiteHistory{
|
||||
TotalChecks: h.TotalChecks,
|
||||
UpChecks: h.UpChecks,
|
||||
Latencies: make([]time.Duration, len(h.Latencies)),
|
||||
Statuses: make([]bool, len(h.Statuses)),
|
||||
}
|
||||
copy(cp.Latencies, h.Latencies)
|
||||
copy(cp.Statuses, h.Statuses)
|
||||
return cp, true
|
||||
}
|
||||
|
||||
func RemoveHistory(siteID int) {
|
||||
historyMu.Lock()
|
||||
defer historyMu.Unlock()
|
||||
delete(histories, siteID)
|
||||
}
|
||||
@@ -0,0 +1,315 @@
|
||||
package monitor
|
||||
|
||||
import (
|
||||
"crypto/tls"
|
||||
"fmt"
|
||||
"go-upkeep/internal/alert"
|
||||
"go-upkeep/internal/models"
|
||||
"go-upkeep/internal/store"
|
||||
"net/http"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// --- LOGGING ---
|
||||
var (
|
||||
LogStore []string
|
||||
LogMutex sync.RWMutex
|
||||
)
|
||||
|
||||
func AddLog(msg string) {
|
||||
LogMutex.Lock()
|
||||
defer LogMutex.Unlock()
|
||||
ts := time.Now().Format("15:04:05")
|
||||
entry := fmt.Sprintf("[%s] %s", ts, msg)
|
||||
LogStore = append([]string{entry}, LogStore...)
|
||||
if len(LogStore) > 100 {
|
||||
LogStore = LogStore[:100]
|
||||
}
|
||||
}
|
||||
|
||||
func GetLogs() []string {
|
||||
LogMutex.RLock()
|
||||
defer LogMutex.RUnlock()
|
||||
logs := make([]string, len(LogStore))
|
||||
copy(logs, LogStore)
|
||||
return logs
|
||||
}
|
||||
|
||||
// --- ENGINE ---
|
||||
|
||||
var (
|
||||
LiveState = make(map[int]models.Site)
|
||||
Mutex sync.RWMutex
|
||||
|
||||
// Global Switch for HA
|
||||
isActive = true
|
||||
activeMutex sync.RWMutex
|
||||
)
|
||||
|
||||
func SetEngineActive(active bool) {
|
||||
activeMutex.Lock()
|
||||
defer activeMutex.Unlock()
|
||||
if isActive != active {
|
||||
isActive = active
|
||||
status := "RESUMED (Active)"
|
||||
if !active {
|
||||
status = "PAUSED (Passive)"
|
||||
}
|
||||
AddLog(fmt.Sprintf("Engine %s", status))
|
||||
}
|
||||
}
|
||||
|
||||
func IsEngineActive() bool {
|
||||
activeMutex.RLock()
|
||||
defer activeMutex.RUnlock()
|
||||
return isActive
|
||||
}
|
||||
|
||||
func RecordHeartbeat(token string) bool {
|
||||
if !IsEngineActive() {
|
||||
return false
|
||||
} // Only Leader accepts Push
|
||||
|
||||
Mutex.Lock()
|
||||
defer Mutex.Unlock()
|
||||
var targetID int = -1
|
||||
for id, s := range LiveState {
|
||||
if s.Type == "push" && s.Token == token {
|
||||
targetID = id
|
||||
break
|
||||
}
|
||||
}
|
||||
if targetID == -1 {
|
||||
return false
|
||||
}
|
||||
|
||||
site := LiveState[targetID]
|
||||
site.LastCheck = time.Now()
|
||||
wasDown := site.Status == "DOWN"
|
||||
site.Status = "UP"
|
||||
site.FailureCount = 0
|
||||
site.Latency = 0
|
||||
LiveState[targetID] = site
|
||||
|
||||
if wasDown {
|
||||
AddLog(fmt.Sprintf("Push Monitor '%s' recovered", site.Name))
|
||||
triggerAlert(site.AlertID, "✅ RECOVERY", fmt.Sprintf("Push Monitor '%s' is receiving heartbeats.", site.Name))
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func StartEngine() {
|
||||
go func() {
|
||||
for {
|
||||
s_instance := store.Get()
|
||||
if s_instance == nil {
|
||||
time.Sleep(1 * time.Second)
|
||||
continue
|
||||
}
|
||||
|
||||
sites := s_instance.GetSites()
|
||||
for _, s := range sites {
|
||||
Mutex.RLock()
|
||||
_, exists := LiveState[s.ID]
|
||||
Mutex.RUnlock()
|
||||
if !exists {
|
||||
Mutex.Lock()
|
||||
s.Status = "PENDING"
|
||||
if s.Type == "push" {
|
||||
s.LastCheck = time.Now()
|
||||
}
|
||||
LiveState[s.ID] = s
|
||||
Mutex.Unlock()
|
||||
go monitorRoutine(s.ID)
|
||||
}
|
||||
}
|
||||
time.Sleep(5 * time.Second)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
func UpdateSiteConfig(id int, name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int) {
|
||||
Mutex.Lock()
|
||||
defer Mutex.Unlock()
|
||||
if s, ok := LiveState[id]; ok {
|
||||
s.Name = name
|
||||
s.URL = url
|
||||
s.Type = sType
|
||||
s.Interval = interval
|
||||
s.AlertID = alertID
|
||||
s.CheckSSL = checkSSL
|
||||
s.ExpiryThreshold = threshold
|
||||
s.MaxRetries = retries
|
||||
LiveState[id] = s
|
||||
}
|
||||
}
|
||||
|
||||
func RemoveSite(id int) {
|
||||
Mutex.Lock()
|
||||
delete(LiveState, id)
|
||||
Mutex.Unlock()
|
||||
RemoveHistory(id)
|
||||
}
|
||||
|
||||
func monitorRoutine(id int) {
|
||||
checkByID(id)
|
||||
for {
|
||||
// If paused, just sleep loop to keep goroutine alive but idle
|
||||
if !IsEngineActive() {
|
||||
time.Sleep(5 * time.Second)
|
||||
continue
|
||||
}
|
||||
|
||||
Mutex.RLock()
|
||||
site, exists := LiveState[id]
|
||||
Mutex.RUnlock()
|
||||
if !exists {
|
||||
return
|
||||
}
|
||||
|
||||
interval := site.Interval
|
||||
if interval < 5 {
|
||||
interval = 5
|
||||
}
|
||||
time.Sleep(time.Duration(interval) * time.Second)
|
||||
checkByID(id)
|
||||
}
|
||||
}
|
||||
|
||||
func checkByID(id int) {
|
||||
if !IsEngineActive() {
|
||||
return
|
||||
}
|
||||
|
||||
Mutex.RLock()
|
||||
site, exists := LiveState[id]
|
||||
Mutex.RUnlock()
|
||||
if !exists {
|
||||
return
|
||||
}
|
||||
if site.Type == "http" {
|
||||
checkHTTP(site)
|
||||
} else {
|
||||
checkPush(site)
|
||||
}
|
||||
}
|
||||
|
||||
func checkPush(site models.Site) {
|
||||
deadline := site.LastCheck.Add(time.Duration(site.Interval) * time.Second).Add(5 * time.Second)
|
||||
if time.Now().After(deadline) {
|
||||
handleStatusChange(site, "DOWN", 0, 0)
|
||||
} else {
|
||||
if site.Status != "UP" {
|
||||
handleStatusChange(site, "UP", 200, 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func checkHTTP(site models.Site) {
|
||||
start := time.Now()
|
||||
client := &http.Client{Timeout: 5 * time.Second, Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}}
|
||||
resp, err := client.Get(site.URL)
|
||||
latency := time.Since(start)
|
||||
|
||||
rawStatus := "UP"
|
||||
rawCode := 0
|
||||
var certExpiry time.Time
|
||||
hasSSL := false
|
||||
|
||||
if err != nil {
|
||||
rawStatus = "DOWN"
|
||||
} else {
|
||||
defer resp.Body.Close()
|
||||
rawCode = resp.StatusCode
|
||||
if resp.StatusCode >= 400 {
|
||||
rawStatus = "DOWN"
|
||||
}
|
||||
if site.CheckSSL && resp.TLS != nil && len(resp.TLS.PeerCertificates) > 0 {
|
||||
hasSSL = true
|
||||
cert := resp.TLS.PeerCertificates[0]
|
||||
certExpiry = cert.NotAfter
|
||||
if time.Now().After(cert.NotAfter) {
|
||||
rawStatus = "SSL EXP"
|
||||
}
|
||||
}
|
||||
}
|
||||
updatedSite := site
|
||||
updatedSite.HasSSL = hasSSL
|
||||
updatedSite.CertExpiry = certExpiry
|
||||
updatedSite.Latency = latency
|
||||
updatedSite.LastCheck = time.Now()
|
||||
handleStatusChange(updatedSite, rawStatus, rawCode, latency)
|
||||
}
|
||||
|
||||
func handleStatusChange(site models.Site, rawStatus string, code int, latency time.Duration) {
|
||||
// Double check we are still leader before alerting
|
||||
if !IsEngineActive() {
|
||||
return
|
||||
}
|
||||
|
||||
newState := site
|
||||
newState.StatusCode = code
|
||||
|
||||
if site.Status == "UP" && rawStatus != "UP" {
|
||||
newState.FailureCount++
|
||||
if newState.FailureCount > site.MaxRetries {
|
||||
newState.Status = rawStatus
|
||||
newState.FailureCount = site.MaxRetries + 1
|
||||
AddLog(fmt.Sprintf("Monitor '%s' confirmed DOWN", site.Name))
|
||||
} else {
|
||||
AddLog(fmt.Sprintf("Monitor '%s' failed check %d/%d", site.Name, newState.FailureCount, site.MaxRetries))
|
||||
}
|
||||
} else if rawStatus == "UP" {
|
||||
newState.FailureCount = 0
|
||||
newState.Status = "UP"
|
||||
} else {
|
||||
newState.Status = rawStatus
|
||||
newState.FailureCount = site.MaxRetries + 1
|
||||
}
|
||||
|
||||
if site.Type == "http" && site.CheckSSL && site.HasSSL {
|
||||
daysLeft := int(time.Until(site.CertExpiry).Hours() / 24)
|
||||
if daysLeft <= site.ExpiryThreshold && !site.SentSSLWarning && rawStatus != "SSL EXP" {
|
||||
triggerAlert(site.AlertID, "SSL WARNING", fmt.Sprintf("SSL for '%s' expires in %d days", site.Name, daysLeft))
|
||||
newState.SentSSLWarning = true
|
||||
} else if daysLeft > site.ExpiryThreshold {
|
||||
newState.SentSSLWarning = false
|
||||
}
|
||||
}
|
||||
|
||||
Mutex.Lock()
|
||||
if _, ok := LiveState[site.ID]; ok {
|
||||
LiveState[site.ID] = newState
|
||||
}
|
||||
Mutex.Unlock()
|
||||
|
||||
RecordCheck(site.ID, latency, rawStatus == "UP")
|
||||
|
||||
isBroken := func(s string) bool { return s == "DOWN" || s == "SSL EXP" }
|
||||
if !isBroken(site.Status) && isBroken(newState.Status) && newState.Status != "PENDING" {
|
||||
msg := fmt.Sprintf("Monitor '%s' is DOWN (%s)", site.Name, rawStatus)
|
||||
if site.Type == "push" {
|
||||
msg = fmt.Sprintf("Push Monitor '%s' missed heartbeat.", site.Name)
|
||||
}
|
||||
triggerAlert(site.AlertID, "🚨 ALERT", msg)
|
||||
}
|
||||
if isBroken(site.Status) && newState.Status == "UP" {
|
||||
triggerAlert(site.AlertID, "✅ RECOVERY", fmt.Sprintf("Monitor '%s' is UP", site.Name))
|
||||
}
|
||||
}
|
||||
|
||||
func triggerAlert(alertID int, title, message string) {
|
||||
s_instance := store.Get()
|
||||
if s_instance == nil {
|
||||
return
|
||||
}
|
||||
cfg, ok := s_instance.GetAlert(alertID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
provider := alert.GetProvider(cfg)
|
||||
if provider != nil {
|
||||
go func() { provider.Send(title, message) }()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"go-upkeep/internal/models"
|
||||
"go-upkeep/internal/monitor"
|
||||
"go-upkeep/internal/store"
|
||||
"html/template"
|
||||
"net/http"
|
||||
"sort"
|
||||
)
|
||||
|
||||
type ServerConfig struct {
|
||||
Port int
|
||||
EnableStatus bool
|
||||
Title string
|
||||
ClusterKey string // Shared Secret for Security
|
||||
}
|
||||
|
||||
func Start(cfg ServerConfig) {
|
||||
mux := http.NewServeMux()
|
||||
|
||||
// 1. Push Heartbeat
|
||||
mux.HandleFunc("/api/push", func(w http.ResponseWriter, r *http.Request) {
|
||||
token := r.URL.Query().Get("token")
|
||||
if token == "" { http.Error(w, "Missing token", 400); return }
|
||||
if monitor.RecordHeartbeat(token) {
|
||||
w.WriteHeader(http.StatusOK); w.Write([]byte("OK"))
|
||||
} else {
|
||||
http.Error(w, "Invalid Token", 404)
|
||||
}
|
||||
})
|
||||
|
||||
// 2. Health Check (For Cluster Follower)
|
||||
mux.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
|
||||
if cfg.ClusterKey != "" && r.Header.Get("X-Upkeep-Secret") != cfg.ClusterKey {
|
||||
http.Error(w, "Unauthorized", 401)
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("OK"))
|
||||
})
|
||||
|
||||
// 3. Config Export
|
||||
mux.HandleFunc("/api/backup/export", func(w http.ResponseWriter, r *http.Request) {
|
||||
if cfg.ClusterKey == "" || r.Header.Get("X-Upkeep-Secret") != cfg.ClusterKey {
|
||||
http.Error(w, "Unauthorized: UPKEEP_CLUSTER_SECRET required", 401)
|
||||
return
|
||||
}
|
||||
data := store.Get().ExportData()
|
||||
json.NewEncoder(w).Encode(data)
|
||||
})
|
||||
|
||||
// 4. Config Import
|
||||
mux.HandleFunc("/api/backup/import", func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != "POST" { http.Error(w, "POST required", 405); return }
|
||||
if cfg.ClusterKey == "" || r.Header.Get("X-Upkeep-Secret") != cfg.ClusterKey {
|
||||
http.Error(w, "Unauthorized", 401)
|
||||
return
|
||||
}
|
||||
var data models.Backup
|
||||
if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
|
||||
http.Error(w, "Invalid JSON", 400)
|
||||
return
|
||||
}
|
||||
if err := store.Get().ImportData(data); err != nil {
|
||||
http.Error(w, "Import Failed: "+err.Error(), 500)
|
||||
return
|
||||
}
|
||||
w.Write([]byte("Import Successful"))
|
||||
})
|
||||
|
||||
// 5. Status Page
|
||||
if cfg.EnableStatus {
|
||||
mux.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) { renderStatusPage(w, cfg.Title) })
|
||||
mux.HandleFunc("/status/json", func(w http.ResponseWriter, r *http.Request) {
|
||||
monitor.Mutex.RLock(); defer monitor.Mutex.RUnlock()
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(monitor.LiveState)
|
||||
})
|
||||
}
|
||||
|
||||
go func() {
|
||||
addr := fmt.Sprintf(":%d", cfg.Port)
|
||||
fmt.Printf("HTTP Server listening on %s\n", addr)
|
||||
http.ListenAndServe(addr, mux)
|
||||
}()
|
||||
}
|
||||
|
||||
func renderStatusPage(w http.ResponseWriter, title string) {
|
||||
monitor.Mutex.RLock()
|
||||
var sites []models.Site
|
||||
for _, s := range monitor.LiveState {
|
||||
sites = append(sites, s)
|
||||
}
|
||||
monitor.Mutex.RUnlock()
|
||||
|
||||
sort.Slice(sites, func(i, j int) bool {
|
||||
if sites[i].Status != sites[j].Status {
|
||||
if sites[i].Status == "DOWN" { return true }
|
||||
if sites[j].Status == "DOWN" { return false }
|
||||
}
|
||||
return sites[i].Name < sites[j].Name
|
||||
})
|
||||
|
||||
const tpl = `
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>{{.Title}}</title>
|
||||
<meta http-equiv="refresh" content="5">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<style>
|
||||
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; background: #1a1b26; color: #a9b1d6; padding: 20px; margin: 0; }
|
||||
h1 { text-align: center; color: #7aa2f7; margin-bottom: 30px; }
|
||||
.container { max-width: 800px; margin: 0 auto; }
|
||||
.card { background: #24283b; padding: 20px; margin-bottom: 15px; border-radius: 8px; display: flex; align-items: center; justify-content: space-between; box-shadow: 0 4px 6px rgba(0,0,0,0.1); }
|
||||
.info { display: flex; flex-direction: column; }
|
||||
.name { font-size: 1.2em; font-weight: bold; color: #c0caf5; margin-bottom: 5px; }
|
||||
.meta { font-size: 0.85em; color: #565f89; }
|
||||
.status { font-weight: bold; padding: 6px 12px; border-radius: 6px; min-width: 60px; text-align: center; }
|
||||
.UP { background: #9ece6a; color: #1a1b26; }
|
||||
.DOWN { background: #f7768e; color: #1a1b26; }
|
||||
.PENDING { background: #e0af68; color: #1a1b26; }
|
||||
.SSLEXP { background: #e0af68; color: #1a1b26; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<h1>{{.Title}}</h1>
|
||||
{{range .Sites}}
|
||||
<div class="card">
|
||||
<div class="info">
|
||||
<div class="name">{{.Name}}</div>
|
||||
<div class="meta">{{.Type}} | {{if eq .Type "http"}}{{.URL}}{{else}}Heartbeat Monitor{{end}}</div>
|
||||
<div class="meta" style="margin-top:4px;">Last Check: {{.LastCheck.Format "15:04:05"}}</div>
|
||||
</div>
|
||||
<div class="status {{.Status}}">{{.Status}}</div>
|
||||
</div>
|
||||
{{end}}
|
||||
<div style="text-align: center; margin-top: 40px; color: #565f89; font-size: 0.8em;">Powered by Go-Upkeep</div>
|
||||
</div>
|
||||
<script>
|
||||
setTimeout(function(){ window.location.reload(1); }, 5000);
|
||||
</script>
|
||||
</body>
|
||||
</html>`
|
||||
|
||||
t, _ := template.New("status").Parse(tpl)
|
||||
data := struct { Title string; Sites []models.Site }{Title: title, Sites: sites}
|
||||
t.Execute(w, data)
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"go-upkeep/internal/models"
|
||||
|
||||
_ "github.com/lib/pq"
|
||||
)
|
||||
|
||||
type PostgresStore struct {
|
||||
ConnStr string
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func (p *PostgresStore) Init() error {
|
||||
var err error
|
||||
p.db, err = sql.Open("postgres", p.ConnStr)
|
||||
if err != nil { return err }
|
||||
|
||||
queries := []string{
|
||||
`CREATE TABLE IF NOT EXISTS alerts (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name TEXT,
|
||||
type TEXT,
|
||||
settings TEXT
|
||||
);`,
|
||||
`CREATE TABLE IF NOT EXISTS sites (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name TEXT DEFAULT 'New Monitor',
|
||||
url TEXT,
|
||||
type TEXT DEFAULT 'http',
|
||||
token TEXT,
|
||||
interval INTEGER,
|
||||
alert_id INTEGER,
|
||||
check_ssl BOOLEAN DEFAULT FALSE,
|
||||
threshold INTEGER DEFAULT 7,
|
||||
max_retries INTEGER DEFAULT 0
|
||||
);`,
|
||||
`CREATE TABLE IF NOT EXISTS users (
|
||||
id SERIAL PRIMARY KEY,
|
||||
username TEXT NOT NULL,
|
||||
public_key TEXT NOT NULL,
|
||||
role TEXT DEFAULT 'user'
|
||||
);`,
|
||||
}
|
||||
for _, q := range queries {
|
||||
if _, err := p.db.Exec(q); err != nil { return err }
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ... [CRUD Methods are identical to Phase 4, keeping them concise here] ...
|
||||
func (p *PostgresStore) GetSites() []models.Site {
|
||||
rows, err := p.db.Query("SELECT id, COALESCE(name, url), url, COALESCE(type, 'http'), COALESCE(token, ''), interval, alert_id, check_ssl, threshold, max_retries FROM sites")
|
||||
if err != nil { return []models.Site{} }
|
||||
defer rows.Close()
|
||||
var sites []models.Site
|
||||
for rows.Next() {
|
||||
var s models.Site
|
||||
rows.Scan(&s.ID, &s.Name, &s.URL, &s.Type, &s.Token, &s.Interval, &s.AlertID, &s.CheckSSL, &s.ExpiryThreshold, &s.MaxRetries)
|
||||
sites = append(sites, s)
|
||||
}
|
||||
return sites
|
||||
}
|
||||
func (p *PostgresStore) AddSite(name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int) {
|
||||
token := ""
|
||||
if sType == "push" { token = generateToken() }
|
||||
p.db.Exec("INSERT INTO sites (name, url, type, token, interval, alert_id, check_ssl, threshold, max_retries) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)", name, url, sType, token, interval, alertID, checkSSL, threshold, retries)
|
||||
}
|
||||
func (p *PostgresStore) UpdateSite(id int, name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int) {
|
||||
var existingToken string
|
||||
p.db.QueryRow("SELECT token FROM sites WHERE id=$1", id).Scan(&existingToken)
|
||||
if sType == "push" && existingToken == "" { existingToken = generateToken() }
|
||||
p.db.Exec("UPDATE sites SET name=$1, url=$2, type=$3, token=$4, interval=$5, alert_id=$6, check_ssl=$7, threshold=$8, max_retries=$9 WHERE id=$10", name, url, sType, existingToken, interval, alertID, checkSSL, threshold, retries, id)
|
||||
}
|
||||
func (p *PostgresStore) DeleteSite(id int) { p.db.Exec("DELETE FROM sites WHERE id=$1", id) }
|
||||
func (p *PostgresStore) GetAllAlerts() []models.AlertConfig {
|
||||
rows, err := p.db.Query("SELECT id, name, type, settings FROM alerts")
|
||||
if err != nil { return []models.AlertConfig{} }
|
||||
defer rows.Close()
|
||||
var alerts []models.AlertConfig
|
||||
for rows.Next() {
|
||||
var a models.AlertConfig; var settingsJSON string
|
||||
rows.Scan(&a.ID, &a.Name, &a.Type, &settingsJSON)
|
||||
json.Unmarshal([]byte(settingsJSON), &a.Settings)
|
||||
alerts = append(alerts, a)
|
||||
}
|
||||
return alerts
|
||||
}
|
||||
func (p *PostgresStore) GetAlert(id int) (models.AlertConfig, bool) {
|
||||
var a models.AlertConfig; var settingsJSON string
|
||||
err := p.db.QueryRow("SELECT id, name, type, settings FROM alerts WHERE id = $1", id).Scan(&a.ID, &a.Name, &a.Type, &settingsJSON)
|
||||
if err != nil { return a, false }
|
||||
json.Unmarshal([]byte(settingsJSON), &a.Settings)
|
||||
return a, true
|
||||
}
|
||||
func (p *PostgresStore) AddAlert(name, aType string, settings map[string]string) {
|
||||
jsonBytes, _ := json.Marshal(settings)
|
||||
p.db.Exec("INSERT INTO alerts (name, type, settings) VALUES ($1, $2, $3)", name, aType, string(jsonBytes))
|
||||
}
|
||||
func (p *PostgresStore) UpdateAlert(id int, name, aType string, settings map[string]string) {
|
||||
jsonBytes, _ := json.Marshal(settings)
|
||||
p.db.Exec("UPDATE alerts SET name=$1, type=$2, settings=$3 WHERE id=$4", name, aType, string(jsonBytes), id)
|
||||
}
|
||||
func (p *PostgresStore) DeleteAlert(id int) { p.db.Exec("DELETE FROM alerts WHERE id=$1", id) }
|
||||
func (p *PostgresStore) GetAllUsers() []models.User {
|
||||
rows, err := p.db.Query("SELECT id, username, public_key, role FROM users")
|
||||
if err != nil { return []models.User{} }
|
||||
defer rows.Close()
|
||||
var users []models.User
|
||||
for rows.Next() {
|
||||
var u models.User
|
||||
rows.Scan(&u.ID, &u.Username, &u.PublicKey, &u.Role)
|
||||
users = append(users, u)
|
||||
}
|
||||
return users
|
||||
}
|
||||
func (p *PostgresStore) AddUser(username, publicKey, role string) error {
|
||||
_, err := p.db.Exec("INSERT INTO users (username, public_key, role) VALUES ($1, $2, $3)", username, publicKey, role)
|
||||
return err
|
||||
}
|
||||
func (p *PostgresStore) DeleteUser(id int) error {
|
||||
_, err := p.db.Exec("DELETE FROM users WHERE id=$1", id)
|
||||
return err
|
||||
}
|
||||
|
||||
// --- PHASE 5 ---
|
||||
|
||||
func (p *PostgresStore) ExportData() models.Backup {
|
||||
return models.Backup{
|
||||
Sites: p.GetSites(),
|
||||
Alerts: p.GetAllAlerts(),
|
||||
Users: p.GetAllUsers(),
|
||||
}
|
||||
}
|
||||
|
||||
func (p *PostgresStore) ImportData(data models.Backup) error {
|
||||
tx, err := p.db.Begin()
|
||||
if err != nil { return err }
|
||||
|
||||
tx.Exec("TRUNCATE TABLE sites RESTART IDENTITY CASCADE")
|
||||
tx.Exec("TRUNCATE TABLE alerts RESTART IDENTITY CASCADE")
|
||||
tx.Exec("TRUNCATE TABLE users RESTART IDENTITY CASCADE")
|
||||
|
||||
for _, u := range data.Users {
|
||||
tx.Exec("INSERT INTO users (username, public_key, role) VALUES ($1, $2, $3)", u.Username, u.PublicKey, u.Role)
|
||||
}
|
||||
for _, a := range data.Alerts {
|
||||
jsonBytes, _ := json.Marshal(a.Settings)
|
||||
tx.Exec("INSERT INTO alerts (id, name, type, settings) VALUES ($1, $2, $3, $4)", a.ID, a.Name, a.Type, string(jsonBytes))
|
||||
}
|
||||
for _, st := range data.Sites {
|
||||
tx.Exec("INSERT INTO sites (id, name, url, type, token, interval, alert_id, check_ssl, threshold, max_retries) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)",
|
||||
st.ID, st.Name, st.URL, st.Type, st.Token, st.Interval, st.AlertID, st.CheckSSL, st.ExpiryThreshold, st.MaxRetries)
|
||||
}
|
||||
|
||||
tx.Exec("SELECT setval('sites_id_seq', (SELECT MAX(id) FROM sites))")
|
||||
tx.Exec("SELECT setval('alerts_id_seq', (SELECT MAX(id) FROM alerts))")
|
||||
tx.Exec("SELECT setval('users_id_seq', (SELECT MAX(id) FROM users))")
|
||||
|
||||
return tx.Commit()
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"go-upkeep/internal/models"
|
||||
|
||||
_ "github.com/mattn/go-sqlite3"
|
||||
)
|
||||
|
||||
type SQLiteStore struct {
|
||||
DBPath string
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func (s *SQLiteStore) Init() error {
|
||||
var err error
|
||||
s.db, err = sql.Open("sqlite3", s.DBPath)
|
||||
if err != nil { return err }
|
||||
|
||||
createTables := `
|
||||
CREATE TABLE IF NOT EXISTS alerts (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name TEXT,
|
||||
type TEXT,
|
||||
settings TEXT
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS sites (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name TEXT DEFAULT 'New Monitor',
|
||||
url TEXT,
|
||||
type TEXT DEFAULT 'http',
|
||||
token TEXT,
|
||||
interval INTEGER,
|
||||
alert_id INTEGER,
|
||||
check_ssl BOOLEAN DEFAULT 0,
|
||||
threshold INTEGER DEFAULT 7,
|
||||
max_retries INTEGER DEFAULT 0
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
username TEXT NOT NULL,
|
||||
public_key TEXT NOT NULL,
|
||||
role TEXT DEFAULT 'user'
|
||||
);`
|
||||
_, err = s.db.Exec(createTables)
|
||||
return err
|
||||
}
|
||||
|
||||
func generateToken() string {
|
||||
b := make([]byte, 16)
|
||||
rand.Read(b)
|
||||
return hex.EncodeToString(b)
|
||||
}
|
||||
|
||||
func (s *SQLiteStore) GetSites() []models.Site {
|
||||
rows, err := s.db.Query("SELECT id, COALESCE(name, url), url, COALESCE(type, 'http'), COALESCE(token, ''), interval, alert_id, check_ssl, threshold, max_retries FROM sites")
|
||||
if err != nil { return []models.Site{} }
|
||||
defer rows.Close()
|
||||
var sites []models.Site
|
||||
for rows.Next() {
|
||||
var st models.Site
|
||||
rows.Scan(&st.ID, &st.Name, &st.URL, &st.Type, &st.Token, &st.Interval, &st.AlertID, &st.CheckSSL, &st.ExpiryThreshold, &st.MaxRetries)
|
||||
sites = append(sites, st)
|
||||
}
|
||||
return sites
|
||||
}
|
||||
func (s *SQLiteStore) AddSite(name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int) {
|
||||
token := ""
|
||||
if sType == "push" { token = generateToken() }
|
||||
s.db.Exec("INSERT INTO sites (name, url, type, token, interval, alert_id, check_ssl, threshold, max_retries) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", name, url, sType, token, interval, alertID, checkSSL, threshold, retries)
|
||||
}
|
||||
func (s *SQLiteStore) UpdateSite(id int, name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int) {
|
||||
var existingToken string
|
||||
s.db.QueryRow("SELECT token FROM sites WHERE id=?", id).Scan(&existingToken)
|
||||
if sType == "push" && existingToken == "" { existingToken = generateToken() }
|
||||
s.db.Exec("UPDATE sites SET name=?, url=?, type=?, token=?, interval=?, alert_id=?, check_ssl=?, threshold=?, max_retries=? WHERE id=?", name, url, sType, existingToken, interval, alertID, checkSSL, threshold, retries, id)
|
||||
}
|
||||
func (s *SQLiteStore) DeleteSite(id int) {
|
||||
s.db.Exec("DELETE FROM sites WHERE id=?", id)
|
||||
var count int
|
||||
s.db.QueryRow("SELECT COUNT(*) FROM sites").Scan(&count)
|
||||
if count == 0 { s.db.Exec("DELETE FROM sqlite_sequence WHERE name='sites'") }
|
||||
}
|
||||
func (s *SQLiteStore) GetAllAlerts() []models.AlertConfig {
|
||||
rows, err := s.db.Query("SELECT id, name, type, settings FROM alerts")
|
||||
if err != nil { return []models.AlertConfig{} }
|
||||
defer rows.Close()
|
||||
var alerts []models.AlertConfig
|
||||
for rows.Next() {
|
||||
var a models.AlertConfig; var settingsJSON string
|
||||
rows.Scan(&a.ID, &a.Name, &a.Type, &settingsJSON)
|
||||
json.Unmarshal([]byte(settingsJSON), &a.Settings)
|
||||
alerts = append(alerts, a)
|
||||
}
|
||||
return alerts
|
||||
}
|
||||
func (s *SQLiteStore) GetAlert(id int) (models.AlertConfig, bool) {
|
||||
var a models.AlertConfig; var settingsJSON string
|
||||
err := s.db.QueryRow("SELECT id, name, type, settings FROM alerts WHERE id = ?", id).Scan(&a.ID, &a.Name, &a.Type, &settingsJSON)
|
||||
if err != nil { return a, false }
|
||||
json.Unmarshal([]byte(settingsJSON), &a.Settings)
|
||||
return a, true
|
||||
}
|
||||
func (s *SQLiteStore) AddAlert(name, aType string, settings map[string]string) {
|
||||
jsonBytes, _ := json.Marshal(settings)
|
||||
s.db.Exec("INSERT INTO alerts (name, type, settings) VALUES (?, ?, ?)", name, aType, string(jsonBytes))
|
||||
}
|
||||
func (s *SQLiteStore) UpdateAlert(id int, name, aType string, settings map[string]string) {
|
||||
jsonBytes, _ := json.Marshal(settings)
|
||||
s.db.Exec("UPDATE alerts SET name=?, type=?, settings=? WHERE id=?", name, aType, string(jsonBytes), id)
|
||||
}
|
||||
func (s *SQLiteStore) DeleteAlert(id int) {
|
||||
s.db.Exec("DELETE FROM alerts WHERE id=?", id)
|
||||
var count int
|
||||
s.db.QueryRow("SELECT COUNT(*) FROM alerts").Scan(&count)
|
||||
if count == 0 { s.db.Exec("DELETE FROM sqlite_sequence WHERE name='alerts'") }
|
||||
}
|
||||
func (s *SQLiteStore) GetAllUsers() []models.User {
|
||||
rows, err := s.db.Query("SELECT id, username, public_key, role FROM users")
|
||||
if err != nil { return []models.User{} }
|
||||
defer rows.Close()
|
||||
var users []models.User
|
||||
for rows.Next() {
|
||||
var u models.User
|
||||
rows.Scan(&u.ID, &u.Username, &u.PublicKey, &u.Role)
|
||||
users = append(users, u)
|
||||
}
|
||||
return users
|
||||
}
|
||||
func (s *SQLiteStore) AddUser(username, publicKey, role string) error {
|
||||
_, err := s.db.Exec("INSERT INTO users (username, public_key, role) VALUES (?, ?, ?)", username, publicKey, role)
|
||||
return err
|
||||
}
|
||||
func (s *SQLiteStore) DeleteUser(id int) error {
|
||||
_, err := s.db.Exec("DELETE FROM users WHERE id=?", id)
|
||||
return err
|
||||
}
|
||||
|
||||
// --- PHASE 5 ---
|
||||
|
||||
func (s *SQLiteStore) ExportData() models.Backup {
|
||||
return models.Backup{
|
||||
Sites: s.GetSites(),
|
||||
Alerts: s.GetAllAlerts(),
|
||||
Users: s.GetAllUsers(),
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SQLiteStore) ImportData(data models.Backup) error {
|
||||
tx, err := s.db.Begin()
|
||||
if err != nil { return err }
|
||||
|
||||
// Wipe Existing
|
||||
tx.Exec("DELETE FROM sites"); tx.Exec("DELETE FROM sqlite_sequence WHERE name='sites'")
|
||||
tx.Exec("DELETE FROM alerts"); tx.Exec("DELETE FROM sqlite_sequence WHERE name='alerts'")
|
||||
tx.Exec("DELETE FROM users"); tx.Exec("DELETE FROM sqlite_sequence WHERE name='users'")
|
||||
|
||||
// Insert New
|
||||
for _, u := range data.Users {
|
||||
tx.Exec("INSERT INTO users (username, public_key, role) VALUES (?, ?, ?)", u.Username, u.PublicKey, u.Role)
|
||||
}
|
||||
for _, a := range data.Alerts {
|
||||
jsonBytes, _ := json.Marshal(a.Settings)
|
||||
tx.Exec("INSERT INTO alerts (id, name, type, settings) VALUES (?, ?, ?, ?)", a.ID, a.Name, a.Type, string(jsonBytes))
|
||||
}
|
||||
for _, st := range data.Sites {
|
||||
tx.Exec("INSERT INTO sites (id, name, url, type, token, interval, alert_id, check_ssl, threshold, max_retries) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
st.ID, st.Name, st.URL, st.Type, st.Token, st.Interval, st.AlertID, st.CheckSSL, st.ExpiryThreshold, st.MaxRetries)
|
||||
}
|
||||
|
||||
return tx.Commit()
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"go-upkeep/internal/models"
|
||||
)
|
||||
|
||||
type Store interface {
|
||||
Init() error
|
||||
|
||||
// Sites
|
||||
GetSites() []models.Site
|
||||
AddSite(name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int)
|
||||
UpdateSite(id int, name, url, sType string, interval, alertID int, checkSSL bool, threshold, retries int)
|
||||
DeleteSite(id int)
|
||||
|
||||
// Alerts
|
||||
GetAllAlerts() []models.AlertConfig
|
||||
GetAlert(id int) (models.AlertConfig, bool)
|
||||
AddAlert(name, aType string, settings map[string]string)
|
||||
UpdateAlert(id int, name, aType string, settings map[string]string)
|
||||
DeleteAlert(id int)
|
||||
|
||||
// Users
|
||||
GetAllUsers() []models.User
|
||||
AddUser(username, publicKey, role string) error
|
||||
DeleteUser(id int) error
|
||||
|
||||
// Phase 5: Backup & Restore
|
||||
ExportData() models.Backup
|
||||
ImportData(data models.Backup) error
|
||||
}
|
||||
|
||||
var Current Store
|
||||
|
||||
func SetGlobal(s Store) {
|
||||
Current = s
|
||||
}
|
||||
|
||||
func Get() Store {
|
||||
return Current
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"go-upkeep/internal/store"
|
||||
|
||||
"github.com/charmbracelet/huh"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
)
|
||||
|
||||
type alertFormData struct {
|
||||
Name string
|
||||
AlertType string
|
||||
WebhookURL string
|
||||
SMTPHost string
|
||||
SMTPPort string
|
||||
SMTPUser string
|
||||
SMTPPass string
|
||||
EmailFrom string
|
||||
EmailTo string
|
||||
}
|
||||
|
||||
func (m Model) viewAlertsTab() string {
|
||||
var content string
|
||||
content += fmt.Sprintf("\n%-3s %-15s %-10s %s\n", "ID", "NAME", "TYPE", "CONFIG")
|
||||
content += subtleStyle.Render("----------------------------------------------------------------") + "\n"
|
||||
end := m.tableOffset + m.maxTableRows
|
||||
if end > len(m.alerts) {
|
||||
end = len(m.alerts)
|
||||
}
|
||||
for i := m.tableOffset; i < end; i++ {
|
||||
alert := m.alerts[i]
|
||||
cursor := " "
|
||||
if m.cursor == i {
|
||||
cursor = ">"
|
||||
}
|
||||
confStr := "settings..."
|
||||
if val, ok := alert.Settings["url"]; ok {
|
||||
confStr = limitStr(val, 30)
|
||||
}
|
||||
if alert.Type == "email" {
|
||||
confStr = fmt.Sprintf("SMTP: %s", alert.Settings["host"])
|
||||
}
|
||||
row := fmt.Sprintf("%s %-3d %-15s %-10s %s", cursor, alert.ID, limitStr(alert.Name, 15), alert.Type, confStr)
|
||||
if m.cursor == i {
|
||||
row = lipgloss.NewStyle().Bold(true).Render(row)
|
||||
}
|
||||
content += row + "\n"
|
||||
}
|
||||
return content
|
||||
}
|
||||
|
||||
func (m *Model) initAlertHuhForm() tea.Cmd {
|
||||
m.alertFormData = &alertFormData{
|
||||
AlertType: "discord",
|
||||
}
|
||||
|
||||
if m.editID > 0 {
|
||||
for _, alert := range m.alerts {
|
||||
if alert.ID == m.editID {
|
||||
m.alertFormData.Name = alert.Name
|
||||
m.alertFormData.AlertType = alert.Type
|
||||
if url, ok := alert.Settings["url"]; ok {
|
||||
m.alertFormData.WebhookURL = url
|
||||
}
|
||||
if alert.Type == "email" {
|
||||
m.alertFormData.SMTPHost = alert.Settings["host"]
|
||||
m.alertFormData.SMTPPort = alert.Settings["port"]
|
||||
m.alertFormData.SMTPUser = alert.Settings["user"]
|
||||
m.alertFormData.SMTPPass = alert.Settings["pass"]
|
||||
m.alertFormData.EmailFrom = alert.Settings["from"]
|
||||
m.alertFormData.EmailTo = alert.Settings["to"]
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m.huhForm = huh.NewForm(
|
||||
huh.NewGroup(
|
||||
huh.NewInput().Title("Alert Name").
|
||||
Placeholder("My Alert Channel").
|
||||
Value(&m.alertFormData.Name).
|
||||
Validate(func(s string) error {
|
||||
if s == "" {
|
||||
return fmt.Errorf("name is required")
|
||||
}
|
||||
return nil
|
||||
}),
|
||||
huh.NewSelect[string]().Title("Alert Type").
|
||||
Options(
|
||||
huh.NewOption("Discord", "discord"),
|
||||
huh.NewOption("Slack", "slack"),
|
||||
huh.NewOption("Webhook", "webhook"),
|
||||
huh.NewOption("Email (SMTP)", "email"),
|
||||
).Value(&m.alertFormData.AlertType),
|
||||
).Title("Alert Config"),
|
||||
huh.NewGroup(
|
||||
huh.NewInput().Title("Webhook URL").
|
||||
Placeholder("https://discord.com/api/webhooks/...").
|
||||
Value(&m.alertFormData.WebhookURL),
|
||||
).Title("Webhook").WithHideFunc(func() bool {
|
||||
return m.alertFormData.AlertType == "email"
|
||||
}),
|
||||
huh.NewGroup(
|
||||
huh.NewInput().Title("SMTP Host").
|
||||
Placeholder("smtp.gmail.com").
|
||||
Value(&m.alertFormData.SMTPHost),
|
||||
huh.NewInput().Title("SMTP Port").
|
||||
Placeholder("587").
|
||||
Value(&m.alertFormData.SMTPPort),
|
||||
huh.NewInput().Title("SMTP User").
|
||||
Placeholder("user@gmail.com").
|
||||
Value(&m.alertFormData.SMTPUser),
|
||||
huh.NewInput().Title("SMTP Password").
|
||||
EchoMode(huh.EchoModePassword).
|
||||
Value(&m.alertFormData.SMTPPass),
|
||||
huh.NewInput().Title("From Email").
|
||||
Placeholder("alerts@domain.com").
|
||||
Value(&m.alertFormData.EmailFrom),
|
||||
huh.NewInput().Title("To Email").
|
||||
Placeholder("oncall@domain.com").
|
||||
Value(&m.alertFormData.EmailTo),
|
||||
).Title("Email Settings").WithHideFunc(func() bool {
|
||||
return m.alertFormData.AlertType != "email"
|
||||
}),
|
||||
).WithTheme(huh.ThemeDracula())
|
||||
|
||||
return m.huhForm.Init()
|
||||
}
|
||||
|
||||
func (m *Model) submitAlertForm() {
|
||||
d := m.alertFormData
|
||||
settings := make(map[string]string)
|
||||
|
||||
if d.AlertType == "email" {
|
||||
settings["host"] = d.SMTPHost
|
||||
settings["port"] = d.SMTPPort
|
||||
settings["user"] = d.SMTPUser
|
||||
settings["pass"] = d.SMTPPass
|
||||
settings["from"] = d.EmailFrom
|
||||
settings["to"] = d.EmailTo
|
||||
} else {
|
||||
settings["url"] = d.WebhookURL
|
||||
}
|
||||
|
||||
if m.editID > 0 {
|
||||
store.Get().UpdateAlert(m.editID, d.Name, d.AlertType, settings)
|
||||
} else {
|
||||
store.Get().AddAlert(d.Name, d.AlertType, settings)
|
||||
}
|
||||
m.state = stateDashboard
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package tui
|
||||
|
||||
func (m Model) viewLogsTab() string {
|
||||
return "\n" + m.logViewport.View()
|
||||
}
|
||||
@@ -0,0 +1,363 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"go-upkeep/internal/models"
|
||||
"go-upkeep/internal/monitor"
|
||||
"go-upkeep/internal/store"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/huh"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
"github.com/charmbracelet/lipgloss/table"
|
||||
)
|
||||
|
||||
var sparkChars = []rune{'▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'}
|
||||
|
||||
var (
|
||||
siteHeaderStyle = lipgloss.NewStyle().
|
||||
Foreground(lipgloss.Color("#7D56F4")).
|
||||
Bold(true).
|
||||
Padding(0, 1)
|
||||
|
||||
siteCellStyle = lipgloss.NewStyle().Padding(0, 1)
|
||||
|
||||
siteSelectedStyle = lipgloss.NewStyle().
|
||||
Padding(0, 1).
|
||||
Bold(true).
|
||||
Foreground(lipgloss.Color("#ffffff")).
|
||||
Background(lipgloss.Color("#3b3b5c"))
|
||||
|
||||
siteBorderStyle = lipgloss.NewStyle().
|
||||
Foreground(lipgloss.Color("#444"))
|
||||
|
||||
siteColWidths = []int{4, 16, 8, 9, 8, 22, 10, 6}
|
||||
)
|
||||
|
||||
type siteFormData struct {
|
||||
Name string
|
||||
SiteType string
|
||||
URL string
|
||||
Interval string
|
||||
AlertID string
|
||||
CheckSSL bool
|
||||
Threshold string
|
||||
Retries string
|
||||
}
|
||||
|
||||
func latencySparkline(latencies []time.Duration, width int) string {
|
||||
if len(latencies) == 0 {
|
||||
return subtleStyle.Render(strings.Repeat("·", width))
|
||||
}
|
||||
|
||||
samples := latencies
|
||||
if len(samples) > width {
|
||||
samples = samples[len(samples)-width:]
|
||||
}
|
||||
|
||||
minL, maxL := samples[0], samples[0]
|
||||
for _, l := range samples {
|
||||
if l < minL {
|
||||
minL = l
|
||||
}
|
||||
if l > maxL {
|
||||
maxL = l
|
||||
}
|
||||
}
|
||||
|
||||
var sb strings.Builder
|
||||
spread := maxL - minL
|
||||
for _, l := range samples {
|
||||
idx := 0
|
||||
if spread > 0 {
|
||||
idx = int(float64(l-minL) / float64(spread) * 7)
|
||||
if idx > 7 {
|
||||
idx = 7
|
||||
}
|
||||
}
|
||||
ch := string(sparkChars[idx])
|
||||
ms := l.Milliseconds()
|
||||
if ms < 200 {
|
||||
sb.WriteString(specialStyle.Render(ch))
|
||||
} else if ms < 500 {
|
||||
sb.WriteString(warnStyle.Render(ch))
|
||||
} else {
|
||||
sb.WriteString(dangerStyle.Render(ch))
|
||||
}
|
||||
}
|
||||
|
||||
if remaining := width - len(samples); remaining > 0 {
|
||||
sb.WriteString(subtleStyle.Render(strings.Repeat("·", remaining)))
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func heartbeatSparkline(statuses []bool, width int) string {
|
||||
if len(statuses) == 0 {
|
||||
return subtleStyle.Render(strings.Repeat("·", width))
|
||||
}
|
||||
|
||||
samples := statuses
|
||||
if len(samples) > width {
|
||||
samples = samples[len(samples)-width:]
|
||||
}
|
||||
|
||||
var sb strings.Builder
|
||||
for _, up := range samples {
|
||||
if up {
|
||||
sb.WriteString(specialStyle.Render("▁"))
|
||||
} else {
|
||||
sb.WriteString(dangerStyle.Render("█"))
|
||||
}
|
||||
}
|
||||
|
||||
if remaining := width - len(samples); remaining > 0 {
|
||||
sb.WriteString(subtleStyle.Render(strings.Repeat("·", remaining)))
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func fmtLatency(d time.Duration) string {
|
||||
ms := d.Milliseconds()
|
||||
if ms == 0 {
|
||||
return subtleStyle.Render("—")
|
||||
}
|
||||
var s string
|
||||
if ms < 1000 {
|
||||
s = fmt.Sprintf("%dms", ms)
|
||||
} else {
|
||||
s = fmt.Sprintf("%.1fs", float64(ms)/1000)
|
||||
}
|
||||
if ms < 200 {
|
||||
return specialStyle.Render(s)
|
||||
}
|
||||
if ms < 500 {
|
||||
return warnStyle.Render(s)
|
||||
}
|
||||
return dangerStyle.Render(s)
|
||||
}
|
||||
|
||||
func fmtUptime(total, up int) string {
|
||||
if total == 0 {
|
||||
return subtleStyle.Render("—")
|
||||
}
|
||||
pct := float64(up) / float64(total) * 100
|
||||
s := fmt.Sprintf("%.1f%%", pct)
|
||||
if pct >= 99 {
|
||||
return specialStyle.Render(s)
|
||||
}
|
||||
if pct >= 95 {
|
||||
return warnStyle.Render(s)
|
||||
}
|
||||
return dangerStyle.Render(s)
|
||||
}
|
||||
|
||||
func fmtSSL(site models.Site) string {
|
||||
if site.Type != "http" || !site.CheckSSL || !site.HasSSL {
|
||||
return subtleStyle.Render("-")
|
||||
}
|
||||
days := int(time.Until(site.CertExpiry).Hours() / 24)
|
||||
s := fmt.Sprintf("%dd", days)
|
||||
if days <= 0 {
|
||||
return dangerStyle.Render("EXPIRED")
|
||||
}
|
||||
if days <= site.ExpiryThreshold {
|
||||
return warnStyle.Render(s)
|
||||
}
|
||||
return specialStyle.Render(s)
|
||||
}
|
||||
|
||||
func fmtRetries(site models.Site) string {
|
||||
retriesDone := site.FailureCount - 1
|
||||
if retriesDone < 0 {
|
||||
retriesDone = 0
|
||||
}
|
||||
dispCount := retriesDone
|
||||
if dispCount > site.MaxRetries {
|
||||
dispCount = site.MaxRetries
|
||||
}
|
||||
s := fmt.Sprintf("%d/%d", dispCount, site.MaxRetries)
|
||||
if site.Status == "DOWN" {
|
||||
return dangerStyle.Render(s)
|
||||
}
|
||||
if site.Status == "UP" && site.FailureCount > 0 {
|
||||
return warnStyle.Render(s)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func fmtStatus(status string) string {
|
||||
switch {
|
||||
case status == "DOWN" || status == "SSL EXP":
|
||||
return dangerStyle.Render(status)
|
||||
case status == "PENDING":
|
||||
return subtleStyle.Render(status)
|
||||
default:
|
||||
return specialStyle.Render(status)
|
||||
}
|
||||
}
|
||||
|
||||
func (m Model) viewSitesTab() string {
|
||||
const sparkWidth = 20
|
||||
|
||||
if len(m.sites) == 0 {
|
||||
return "\n No sites configured. Press [n] to add one."
|
||||
}
|
||||
|
||||
end := m.tableOffset + m.maxTableRows
|
||||
if end > len(m.sites) {
|
||||
end = len(m.sites)
|
||||
}
|
||||
|
||||
selectedVisual := m.cursor - m.tableOffset
|
||||
|
||||
var rows [][]string
|
||||
for i := m.tableOffset; i < end; i++ {
|
||||
site := m.sites[i]
|
||||
hist, _ := monitor.GetHistory(site.ID)
|
||||
|
||||
var spark string
|
||||
if site.Type == "push" {
|
||||
spark = heartbeatSparkline(hist.Statuses, sparkWidth)
|
||||
} else {
|
||||
spark = latencySparkline(hist.Latencies, sparkWidth)
|
||||
}
|
||||
|
||||
rows = append(rows, []string{
|
||||
strconv.Itoa(site.ID),
|
||||
m.zones.Mark(fmt.Sprintf("site-%d", i), limitStr(site.Name, 15)),
|
||||
fmtStatus(site.Status),
|
||||
fmtLatency(site.Latency),
|
||||
fmtUptime(hist.TotalChecks, hist.UpChecks),
|
||||
spark,
|
||||
fmtSSL(site),
|
||||
fmtRetries(site),
|
||||
})
|
||||
}
|
||||
|
||||
t := table.New().
|
||||
Border(lipgloss.RoundedBorder()).
|
||||
BorderStyle(siteBorderStyle).
|
||||
Headers("ID", "NAME", "STATUS", "LATENCY", "UPTIME", "HISTORY", "SSL", "RETRY").
|
||||
Rows(rows...).
|
||||
StyleFunc(func(row, col int) lipgloss.Style {
|
||||
if row == table.HeaderRow {
|
||||
s := siteHeaderStyle
|
||||
if col < len(siteColWidths) {
|
||||
s = s.Width(siteColWidths[col])
|
||||
}
|
||||
return s
|
||||
}
|
||||
s := siteCellStyle
|
||||
if row == selectedVisual {
|
||||
s = siteSelectedStyle
|
||||
}
|
||||
if col < len(siteColWidths) {
|
||||
s = s.Width(siteColWidths[col])
|
||||
}
|
||||
return s
|
||||
})
|
||||
|
||||
return "\n" + t.Render()
|
||||
}
|
||||
|
||||
func (m *Model) initSiteHuhForm() tea.Cmd {
|
||||
m.siteFormData = &siteFormData{
|
||||
SiteType: "http",
|
||||
Interval: "60",
|
||||
Threshold: "7",
|
||||
Retries: "0",
|
||||
}
|
||||
|
||||
if m.editID > 0 {
|
||||
for _, site := range m.sites {
|
||||
if site.ID == m.editID {
|
||||
m.siteFormData.Name = site.Name
|
||||
m.siteFormData.SiteType = site.Type
|
||||
m.siteFormData.URL = site.URL
|
||||
m.siteFormData.Interval = strconv.Itoa(site.Interval)
|
||||
m.siteFormData.AlertID = strconv.Itoa(site.AlertID)
|
||||
m.siteFormData.CheckSSL = site.CheckSSL
|
||||
m.siteFormData.Threshold = strconv.Itoa(site.ExpiryThreshold)
|
||||
m.siteFormData.Retries = strconv.Itoa(site.MaxRetries)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
alertOpts := []huh.Option[string]{huh.NewOption("None", "0")}
|
||||
if store.Get() != nil {
|
||||
for _, a := range store.Get().GetAllAlerts() {
|
||||
alertOpts = append(alertOpts, huh.NewOption(
|
||||
fmt.Sprintf("%s (%s)", a.Name, a.Type),
|
||||
strconv.Itoa(a.ID),
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
m.huhForm = huh.NewForm(
|
||||
huh.NewGroup(
|
||||
huh.NewInput().Title("Monitor Name").
|
||||
Placeholder("My Service").
|
||||
Value(&m.siteFormData.Name).
|
||||
Validate(func(s string) error {
|
||||
if s == "" {
|
||||
return fmt.Errorf("name is required")
|
||||
}
|
||||
return nil
|
||||
}),
|
||||
huh.NewSelect[string]().Title("Monitor Type").
|
||||
Options(
|
||||
huh.NewOption("HTTP/HTTPS", "http"),
|
||||
huh.NewOption("Push / Heartbeat", "push"),
|
||||
).Value(&m.siteFormData.SiteType),
|
||||
huh.NewInput().Title("URL").
|
||||
Placeholder("https://example.com").
|
||||
Description("Required for HTTP monitors").
|
||||
Value(&m.siteFormData.URL),
|
||||
huh.NewInput().Title("Check Interval (seconds)").
|
||||
Placeholder("60").
|
||||
Value(&m.siteFormData.Interval),
|
||||
huh.NewSelect[string]().Title("Alert Channel").
|
||||
Options(alertOpts...).
|
||||
Value(&m.siteFormData.AlertID),
|
||||
).Title("Monitor Settings"),
|
||||
huh.NewGroup(
|
||||
huh.NewConfirm().Title("Monitor SSL Certificate?").
|
||||
Value(&m.siteFormData.CheckSSL),
|
||||
huh.NewInput().Title("SSL Warning Threshold (days)").
|
||||
Placeholder("7").
|
||||
Value(&m.siteFormData.Threshold),
|
||||
huh.NewInput().Title("Max Retries Before Alert").
|
||||
Placeholder("0").
|
||||
Value(&m.siteFormData.Retries),
|
||||
).Title("Advanced"),
|
||||
).WithTheme(huh.ThemeDracula())
|
||||
|
||||
return m.huhForm.Init()
|
||||
}
|
||||
|
||||
func (m *Model) submitSiteForm() {
|
||||
d := m.siteFormData
|
||||
interval, _ := strconv.Atoi(d.Interval)
|
||||
alertID, _ := strconv.Atoi(d.AlertID)
|
||||
threshold, _ := strconv.Atoi(d.Threshold)
|
||||
retries, _ := strconv.Atoi(d.Retries)
|
||||
if interval < 1 {
|
||||
interval = 60
|
||||
}
|
||||
if threshold < 1 {
|
||||
threshold = 7
|
||||
}
|
||||
|
||||
if m.editID > 0 {
|
||||
store.Get().UpdateSite(m.editID, d.Name, d.URL, d.SiteType, interval, alertID, d.CheckSSL, threshold, retries)
|
||||
monitor.UpdateSiteConfig(m.editID, d.Name, d.URL, d.SiteType, interval, alertID, d.CheckSSL, threshold, retries)
|
||||
} else {
|
||||
store.Get().AddSite(d.Name, d.URL, d.SiteType, interval, alertID, d.CheckSSL, threshold, retries)
|
||||
}
|
||||
m.state = stateDashboard
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"go-upkeep/internal/store"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/huh"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
)
|
||||
|
||||
type userFormData struct {
|
||||
Username string
|
||||
PublicKey string
|
||||
}
|
||||
|
||||
func (m Model) viewUsersTab() string {
|
||||
var content string
|
||||
content += fmt.Sprintf("\n%-3s %-15s %-10s %s\n", "ID", "USER", "ROLE", "KEY")
|
||||
content += subtleStyle.Render("----------------------------------------------------------------") + "\n"
|
||||
end := m.tableOffset + m.maxTableRows
|
||||
if end > len(m.users) {
|
||||
end = len(m.users)
|
||||
}
|
||||
for i := m.tableOffset; i < end; i++ {
|
||||
u := m.users[i]
|
||||
cursor := " "
|
||||
if m.cursor == i {
|
||||
cursor = ">"
|
||||
}
|
||||
row := fmt.Sprintf("%s %-3d %-15s %-10s %s", cursor, u.ID, limitStr(u.Username, 15), u.Role, limitStr(u.PublicKey, 40))
|
||||
if m.cursor == i {
|
||||
row = lipgloss.NewStyle().Bold(true).Render(row)
|
||||
}
|
||||
content += row + "\n"
|
||||
}
|
||||
return content
|
||||
}
|
||||
|
||||
func (m *Model) initUserHuhForm() tea.Cmd {
|
||||
m.userFormData = &userFormData{}
|
||||
|
||||
m.huhForm = huh.NewForm(
|
||||
huh.NewGroup(
|
||||
huh.NewInput().Title("Username").
|
||||
Placeholder("admin").
|
||||
Value(&m.userFormData.Username).
|
||||
Validate(func(s string) error {
|
||||
if s == "" {
|
||||
return fmt.Errorf("username is required")
|
||||
}
|
||||
return nil
|
||||
}),
|
||||
huh.NewInput().Title("SSH Public Key").
|
||||
Placeholder("ssh-ed25519 AAAA...").
|
||||
Value(&m.userFormData.PublicKey).
|
||||
Validate(func(s string) error {
|
||||
if s == "" {
|
||||
return fmt.Errorf("public key is required")
|
||||
}
|
||||
return nil
|
||||
}),
|
||||
).Title("SSH Access"),
|
||||
).WithTheme(huh.ThemeDracula())
|
||||
|
||||
return m.huhForm.Init()
|
||||
}
|
||||
|
||||
func (m *Model) submitUserForm() {
|
||||
store.Get().AddUser(m.userFormData.Username, m.userFormData.PublicKey, "user")
|
||||
m.state = stateUsers
|
||||
}
|
||||
@@ -0,0 +1,426 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"go-upkeep/internal/models"
|
||||
"go-upkeep/internal/monitor"
|
||||
"go-upkeep/internal/store"
|
||||
"math"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/charmbracelet/bubbles/viewport"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/harmonica"
|
||||
"github.com/charmbracelet/huh"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
zone "github.com/lrstanley/bubblezone"
|
||||
)
|
||||
|
||||
var (
|
||||
subtleStyle = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#D9DCCF", Dark: "#383838"})
|
||||
specialStyle = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#43BF6D", Dark: "#73F59F"})
|
||||
warnStyle = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#F0E442", Dark: "#F0E442"})
|
||||
dangerStyle = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#F25D94", Dark: "#F25D94"})
|
||||
titleStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#7D56F4")).Bold(true)
|
||||
|
||||
activeTab = lipgloss.NewStyle().Border(lipgloss.NormalBorder(), false, false, true, false).BorderForeground(lipgloss.Color("#7D56F4")).Foreground(lipgloss.Color("#7D56F4")).Bold(true).Padding(0, 1)
|
||||
inactiveTab = lipgloss.NewStyle().Padding(0, 1).Foreground(lipgloss.AdaptiveColor{Light: "#AAA", Dark: "#555"})
|
||||
)
|
||||
|
||||
var pulseFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
|
||||
|
||||
type sessionState int
|
||||
|
||||
const (
|
||||
stateDashboard sessionState = iota
|
||||
stateLogs
|
||||
stateUsers
|
||||
stateFormSite
|
||||
stateFormAlert
|
||||
stateFormUser
|
||||
)
|
||||
|
||||
type Model struct {
|
||||
state sessionState
|
||||
currentTab int
|
||||
cursor int
|
||||
tableOffset int
|
||||
maxTableRows int
|
||||
editID int
|
||||
editToken string
|
||||
|
||||
huhForm *huh.Form
|
||||
siteFormData *siteFormData
|
||||
alertFormData *alertFormData
|
||||
userFormData *userFormData
|
||||
|
||||
logViewport viewport.Model
|
||||
isAdmin bool
|
||||
zones *zone.Manager
|
||||
|
||||
// harmonica animation state
|
||||
pulseSpring harmonica.Spring
|
||||
pulsePos float64
|
||||
pulseVel float64
|
||||
tickCount int
|
||||
|
||||
sites []models.Site
|
||||
alerts []models.AlertConfig
|
||||
users []models.User
|
||||
}
|
||||
|
||||
func InitialModel(isAdmin bool) Model {
|
||||
vpLogs := viewport.New(100, 20)
|
||||
vpLogs.SetContent("Waiting for logs...")
|
||||
z := zone.New()
|
||||
spring := harmonica.NewSpring(harmonica.FPS(10), 6.0, 0.4)
|
||||
return Model{
|
||||
state: stateDashboard,
|
||||
logViewport: vpLogs,
|
||||
maxTableRows: 5,
|
||||
isAdmin: isAdmin,
|
||||
zones: z,
|
||||
pulseSpring: spring,
|
||||
}
|
||||
}
|
||||
|
||||
func (m Model) Init() tea.Cmd {
|
||||
return tea.Batch(tea.ClearScreen, tea.Tick(time.Second, func(t time.Time) tea.Msg { return t }))
|
||||
}
|
||||
|
||||
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
var cmd tea.Cmd
|
||||
|
||||
// Form state: forward ALL messages to huh (keys, timers, resize, etc.)
|
||||
if m.state == stateFormSite || m.state == stateFormAlert || m.state == stateFormUser {
|
||||
if keyMsg, ok := msg.(tea.KeyMsg); ok {
|
||||
if keyMsg.String() == "ctrl+c" {
|
||||
return m, tea.Quit
|
||||
}
|
||||
if keyMsg.String() == "esc" {
|
||||
m.huhForm = nil
|
||||
m.state = stateDashboard
|
||||
if m.currentTab == 3 {
|
||||
m.state = stateUsers
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
}
|
||||
if m.huhForm != nil {
|
||||
form, formCmd := m.huhForm.Update(msg)
|
||||
if f, ok := form.(*huh.Form); ok {
|
||||
m.huhForm = f
|
||||
}
|
||||
if m.huhForm.State == huh.StateCompleted {
|
||||
m.submitForm()
|
||||
m.refreshData()
|
||||
m.huhForm = nil
|
||||
return m, nil
|
||||
}
|
||||
return m, formCmd
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
switch msg := msg.(type) {
|
||||
case tea.WindowSizeMsg:
|
||||
m.maxTableRows = msg.Height - 12
|
||||
if m.maxTableRows < 1 {
|
||||
m.maxTableRows = 1
|
||||
}
|
||||
m.logViewport.Width = msg.Width
|
||||
m.logViewport.Height = msg.Height - 6
|
||||
return m, tea.ClearScreen
|
||||
|
||||
case time.Time:
|
||||
m.refreshData()
|
||||
m.tickCount++
|
||||
target := math.Sin(float64(m.tickCount)*0.3)*0.5 + 0.5
|
||||
m.pulsePos, m.pulseVel = m.pulseSpring.Update(m.pulsePos, m.pulseVel, target)
|
||||
return m, tea.Tick(time.Second, func(t time.Time) tea.Msg { return t })
|
||||
|
||||
case tea.MouseMsg:
|
||||
if m.state == stateDashboard || m.state == stateLogs || m.state == stateUsers {
|
||||
if msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
|
||||
return m.handleClick(msg)
|
||||
}
|
||||
}
|
||||
|
||||
case tea.KeyMsg:
|
||||
if msg.String() == "ctrl+c" {
|
||||
return m, tea.Quit
|
||||
}
|
||||
if msg.String() == "ctrl+l" {
|
||||
return m, tea.ClearScreen
|
||||
}
|
||||
|
||||
switch m.state {
|
||||
case stateDashboard, stateLogs, stateUsers:
|
||||
switch msg.String() {
|
||||
case "q":
|
||||
return m, tea.Quit
|
||||
case "tab":
|
||||
m.switchTab(m.currentTab + 1)
|
||||
case "pgup", "pgdown":
|
||||
if m.state == stateLogs {
|
||||
m.logViewport, cmd = m.logViewport.Update(msg)
|
||||
return m, cmd
|
||||
}
|
||||
case "up", "k":
|
||||
if m.state == stateLogs {
|
||||
m.logViewport.LineUp(1)
|
||||
} else if m.cursor > 0 {
|
||||
m.cursor--
|
||||
if m.cursor < m.tableOffset {
|
||||
m.tableOffset = m.cursor
|
||||
}
|
||||
}
|
||||
case "down", "j":
|
||||
if m.state == stateLogs {
|
||||
m.logViewport.LineDown(1)
|
||||
} else {
|
||||
max := len(m.sites) - 1
|
||||
if m.currentTab == 1 {
|
||||
max = len(m.alerts) - 1
|
||||
}
|
||||
if m.currentTab == 3 {
|
||||
max = len(m.users) - 1
|
||||
}
|
||||
if m.cursor < max {
|
||||
m.cursor++
|
||||
if m.cursor >= m.tableOffset+m.maxTableRows {
|
||||
m.tableOffset++
|
||||
}
|
||||
}
|
||||
}
|
||||
case "n":
|
||||
m.editID = 0
|
||||
m.editToken = ""
|
||||
if m.currentTab == 0 {
|
||||
m.state = stateFormSite
|
||||
return m, m.initSiteHuhForm()
|
||||
} else if m.currentTab == 1 {
|
||||
m.state = stateFormAlert
|
||||
return m, m.initAlertHuhForm()
|
||||
} else if m.currentTab == 3 && m.isAdmin {
|
||||
m.state = stateFormUser
|
||||
return m, m.initUserHuhForm()
|
||||
}
|
||||
case "e", "enter":
|
||||
if m.currentTab == 0 && len(m.sites) > 0 {
|
||||
m.editID = m.sites[m.cursor].ID
|
||||
m.editToken = m.sites[m.cursor].Token
|
||||
m.state = stateFormSite
|
||||
return m, m.initSiteHuhForm()
|
||||
} else if m.currentTab == 1 && len(m.alerts) > 0 {
|
||||
m.editID = m.alerts[m.cursor].ID
|
||||
m.state = stateFormAlert
|
||||
return m, m.initAlertHuhForm()
|
||||
}
|
||||
case "d", "backspace":
|
||||
if m.currentTab == 1 && len(m.alerts) > 0 {
|
||||
store.Get().DeleteAlert(m.alerts[m.cursor].ID)
|
||||
m.adjustCursor(len(m.alerts) - 1)
|
||||
} else if m.currentTab == 0 && len(m.sites) > 0 {
|
||||
id := m.sites[m.cursor].ID
|
||||
store.Get().DeleteSite(id)
|
||||
monitor.RemoveSite(id)
|
||||
m.adjustCursor(len(m.sites) - 1)
|
||||
} else if m.currentTab == 3 && m.isAdmin && len(m.users) > 0 {
|
||||
store.Get().DeleteUser(m.users[m.cursor].ID)
|
||||
m.adjustCursor(len(m.users) - 1)
|
||||
}
|
||||
m.refreshData()
|
||||
}
|
||||
}
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m *Model) handleClick(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
|
||||
maxTabs := 3
|
||||
if !m.isAdmin {
|
||||
maxTabs = 2
|
||||
}
|
||||
for i := 0; i <= maxTabs; i++ {
|
||||
if m.zones.Get(fmt.Sprintf("tab-%d", i)).InBounds(msg) {
|
||||
m.switchTab(i)
|
||||
return m, nil
|
||||
}
|
||||
}
|
||||
|
||||
if m.currentTab == 0 {
|
||||
end := m.tableOffset + m.maxTableRows
|
||||
if end > len(m.sites) {
|
||||
end = len(m.sites)
|
||||
}
|
||||
for i := m.tableOffset; i < end; i++ {
|
||||
if m.zones.Get(fmt.Sprintf("site-%d", i)).InBounds(msg) {
|
||||
m.cursor = i
|
||||
return m, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m *Model) switchTab(idx int) {
|
||||
maxTabs := 2
|
||||
if m.isAdmin {
|
||||
maxTabs = 3
|
||||
}
|
||||
if idx > maxTabs {
|
||||
idx = 0
|
||||
}
|
||||
m.currentTab = idx
|
||||
m.cursor = 0
|
||||
m.tableOffset = 0
|
||||
switch idx {
|
||||
case 2:
|
||||
m.state = stateLogs
|
||||
case 3:
|
||||
m.state = stateUsers
|
||||
default:
|
||||
m.state = stateDashboard
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Model) adjustCursor(newLen int) {
|
||||
if m.cursor >= newLen && m.cursor > 0 {
|
||||
m.cursor--
|
||||
}
|
||||
if m.cursor < m.tableOffset {
|
||||
m.tableOffset = m.cursor
|
||||
if m.tableOffset < 0 {
|
||||
m.tableOffset = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Model) refreshData() {
|
||||
monitor.Mutex.RLock()
|
||||
var sites []models.Site
|
||||
for _, s := range monitor.LiveState {
|
||||
sites = append(sites, s)
|
||||
}
|
||||
monitor.Mutex.RUnlock()
|
||||
sort.Slice(sites, func(i, j int) bool { return sites[i].ID < sites[j].ID })
|
||||
m.sites = sites
|
||||
if store.Get() != nil {
|
||||
m.alerts = store.Get().GetAllAlerts()
|
||||
if m.isAdmin {
|
||||
m.users = store.Get().GetAllUsers()
|
||||
}
|
||||
}
|
||||
m.logViewport.SetContent(strings.Join(monitor.GetLogs(), "\n"))
|
||||
}
|
||||
|
||||
func (m *Model) submitForm() {
|
||||
if store.Get() == nil {
|
||||
return
|
||||
}
|
||||
switch m.state {
|
||||
case stateFormSite:
|
||||
if m.siteFormData != nil {
|
||||
m.submitSiteForm()
|
||||
}
|
||||
case stateFormAlert:
|
||||
if m.alertFormData != nil {
|
||||
m.submitAlertForm()
|
||||
}
|
||||
case stateFormUser:
|
||||
if m.userFormData != nil {
|
||||
m.submitUserForm()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m Model) pulseIndicator() string {
|
||||
frame := m.tickCount % len(pulseFrames)
|
||||
brightness := int(m.pulsePos*155) + 100
|
||||
if brightness > 255 {
|
||||
brightness = 255
|
||||
}
|
||||
color := fmt.Sprintf("#%02x%02x%02x", brightness/3, brightness, brightness/2)
|
||||
return lipgloss.NewStyle().Foreground(lipgloss.Color(color)).Render(pulseFrames[frame])
|
||||
}
|
||||
|
||||
func (m Model) View() string {
|
||||
switch m.state {
|
||||
case stateFormSite, stateFormAlert, stateFormUser:
|
||||
if m.huhForm != nil {
|
||||
title := ""
|
||||
switch m.state {
|
||||
case stateFormSite:
|
||||
title = "Add Monitor"
|
||||
if m.editID > 0 {
|
||||
title = fmt.Sprintf("Edit Monitor #%d", m.editID)
|
||||
}
|
||||
case stateFormAlert:
|
||||
title = "Add Alert"
|
||||
if m.editID > 0 {
|
||||
title = fmt.Sprintf("Edit Alert #%d", m.editID)
|
||||
}
|
||||
case stateFormUser:
|
||||
title = "Add User"
|
||||
}
|
||||
header := titleStyle.Render(title)
|
||||
footer := subtleStyle.Render("\n[Esc] Cancel")
|
||||
return lipgloss.NewStyle().Padding(1, 2).Render(header + "\n\n" + m.huhForm.View() + "\n" + footer)
|
||||
}
|
||||
return ""
|
||||
default:
|
||||
return m.zones.Scan(m.viewDashboard())
|
||||
}
|
||||
}
|
||||
|
||||
func (m Model) viewDashboard() string {
|
||||
tabs := []string{"Sites", "Alerts", "Logs"}
|
||||
if m.isAdmin {
|
||||
tabs = append(tabs, "Users")
|
||||
}
|
||||
var renderedTabs []string
|
||||
for i, t := range tabs {
|
||||
var rendered string
|
||||
if i == m.currentTab {
|
||||
rendered = activeTab.Render(t)
|
||||
} else {
|
||||
rendered = inactiveTab.Render(t)
|
||||
}
|
||||
renderedTabs = append(renderedTabs, m.zones.Mark(fmt.Sprintf("tab-%d", i), rendered))
|
||||
}
|
||||
header := lipgloss.JoinHorizontal(lipgloss.Top, renderedTabs...)
|
||||
|
||||
pulse := m.pulseIndicator()
|
||||
header = pulse + " " + header
|
||||
|
||||
var content string
|
||||
switch m.currentTab {
|
||||
case 0:
|
||||
content = m.viewSitesTab()
|
||||
case 1:
|
||||
content = m.viewAlertsTab()
|
||||
case 2:
|
||||
content = m.viewLogsTab()
|
||||
case 3:
|
||||
if m.isAdmin {
|
||||
content = m.viewUsersTab()
|
||||
}
|
||||
}
|
||||
|
||||
footer := subtleStyle.Render("\n[n] New [e/Enter] Edit [d] Delete [Tab/Click] Switch [Ctrl+L] Clear [q] Quit")
|
||||
if m.currentTab == 3 {
|
||||
footer = subtleStyle.Render("\n[n] Add User [d] Revoke [Tab/Click] Switch [Ctrl+L] Clear [q] Quit")
|
||||
}
|
||||
return lipgloss.NewStyle().Padding(1, 2).Render(header + "\n" + content + "\n" + footer)
|
||||
}
|
||||
|
||||
func limitStr(text string, max int) string {
|
||||
if len(text) > max {
|
||||
return text[:max-3] + "..."
|
||||
}
|
||||
return text
|
||||
}
|
||||
Reference in New Issue
Block a user