265 lines
7.2 KiB
Go
265 lines
7.2 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"compress/gzip"
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type MaintenanceMetrics struct {
|
|
Available bool `json:"available"`
|
|
ProxmoxVersion string `json:"proxmoxVersion"`
|
|
KernelVersion string `json:"kernelVersion"`
|
|
LatestInstalledKernel string `json:"latestInstalledKernel"`
|
|
NewKernelAvailable bool `json:"newKernelAvailable"`
|
|
RebootRequired bool `json:"rebootRequired"`
|
|
AvailableUpdates int `json:"availableUpdates"`
|
|
LastSystemUpdate time.Time `json:"lastSystemUpdate"`
|
|
NextBackup string `json:"nextBackup"`
|
|
NextScrub string `json:"nextScrub"`
|
|
CheckedAt time.Time `json:"checkedAt"`
|
|
}
|
|
|
|
type maintenanceCollector struct {
|
|
mu sync.Mutex
|
|
cached MaintenanceMetrics
|
|
updatedAt time.Time
|
|
refreshing bool
|
|
}
|
|
|
|
func (c *maintenanceCollector) collect() MaintenanceMetrics {
|
|
c.mu.Lock()
|
|
if time.Since(c.updatedAt) >= 15*time.Minute && !c.refreshing {
|
|
c.refreshing = true
|
|
go func() {
|
|
metrics := readMaintenance()
|
|
c.mu.Lock()
|
|
c.cached = metrics
|
|
c.updatedAt = time.Now()
|
|
c.refreshing = false
|
|
c.mu.Unlock()
|
|
}()
|
|
}
|
|
result := c.cached
|
|
c.mu.Unlock()
|
|
return result
|
|
}
|
|
|
|
func commandOutput(timeout time.Duration, name string, args ...string) string {
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
command := exec.CommandContext(ctx, name, args...)
|
|
command.Env = append(os.Environ(), "LC_ALL=C")
|
|
output, err := command.Output()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(string(output))
|
|
}
|
|
|
|
func readMaintenance() MaintenanceMetrics {
|
|
result := MaintenanceMetrics{Available: true, CheckedAt: time.Now()}
|
|
result.ProxmoxVersion = firstLine(commandOutput(5*time.Second, "pveversion"))
|
|
result.KernelVersion = commandOutput(3*time.Second, "uname", "-r")
|
|
result.RebootRequired = fileExists("/var/run/reboot-required")
|
|
apt := commandOutput(45*time.Second, "apt-get", "-s", "-o", "Debug::NoLocking=1", "upgrade")
|
|
for _, line := range strings.Split(apt, "\n") {
|
|
if strings.HasPrefix(line, "Inst ") {
|
|
result.AvailableUpdates++
|
|
}
|
|
}
|
|
result.LastSystemUpdate = lastAPTUpdate("/var/log/apt/history.log")
|
|
installed := commandOutput(8*time.Second, "dpkg-query", "-W", "-f=${Package} ${Version}\\n", "pve-kernel-*", "proxmox-kernel-*")
|
|
result.LatestInstalledKernel = newestKernel(installed)
|
|
result.NewKernelAvailable = result.LatestInstalledKernel != "" && !strings.Contains(result.KernelVersion, result.LatestInstalledKernel)
|
|
result.NextBackup = nextBackupSchedule()
|
|
result.NextScrub = nextScrubTimer(commandOutput(8*time.Second, "systemctl", "list-timers", "--all", "--no-legend", "--plain"))
|
|
if result.NextScrub == "" {
|
|
result.NextScrub = nextZFSScrubCron("/etc/cron.d/zfsutils-linux", time.Now())
|
|
}
|
|
return result
|
|
}
|
|
|
|
func firstLine(value string) string {
|
|
if i := strings.IndexByte(value, '\n'); i >= 0 {
|
|
return value[:i]
|
|
}
|
|
return value
|
|
}
|
|
func fileExists(path string) bool { _, err := os.Stat(path); return err == nil }
|
|
|
|
func lastAPTUpdate(path string) time.Time {
|
|
file, err := os.Open(path)
|
|
if err == nil {
|
|
defer file.Close()
|
|
if result := scanAPTUpdate(file); !result.IsZero() {
|
|
return result
|
|
}
|
|
}
|
|
files, _ := filepath.Glob(path + ".*.gz")
|
|
sort.Slice(files, func(i, j int) bool {
|
|
a, _ := os.Stat(files[i])
|
|
b, _ := os.Stat(files[j])
|
|
return a.ModTime().After(b.ModTime())
|
|
})
|
|
for _, name := range files {
|
|
compressed, err := os.Open(name)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
reader, err := gzip.NewReader(compressed)
|
|
if err != nil {
|
|
compressed.Close()
|
|
continue
|
|
}
|
|
result := scanAPTUpdate(reader)
|
|
reader.Close()
|
|
compressed.Close()
|
|
if !result.IsZero() {
|
|
return result
|
|
}
|
|
}
|
|
return time.Time{}
|
|
}
|
|
func scanAPTUpdate(reader io.Reader) time.Time {
|
|
scanner := bufio.NewScanner(reader)
|
|
var result time.Time
|
|
for scanner.Scan() {
|
|
line := strings.TrimSpace(scanner.Text())
|
|
if strings.HasPrefix(line, "End-Date:") {
|
|
value := strings.TrimSpace(strings.TrimPrefix(line, "End-Date:"))
|
|
if parsed, err := time.ParseInLocation("2006-01-02 15:04:05", value, time.Local); err == nil {
|
|
result = parsed
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
var versionNumbers = regexp.MustCompile(`\d+`)
|
|
|
|
func newestKernel(output string) string {
|
|
var versions []string
|
|
for _, line := range strings.Split(output, "\n") {
|
|
fields := strings.Fields(line)
|
|
if len(fields) > 1 && !strings.Contains(fields[0], "helper") {
|
|
versions = append(versions, fields[1])
|
|
}
|
|
}
|
|
sort.Slice(versions, func(i, j int) bool { return compareNumericVersion(versions[i], versions[j]) > 0 })
|
|
if len(versions) > 0 {
|
|
return versions[0]
|
|
}
|
|
return ""
|
|
}
|
|
func compareNumericVersion(a, b string) int {
|
|
aa, bb := versionNumbers.FindAllString(a, -1), versionNumbers.FindAllString(b, -1)
|
|
for i := 0; i < len(aa) || i < len(bb); i++ {
|
|
av, bv := "0", "0"
|
|
if i < len(aa) {
|
|
av = aa[i]
|
|
}
|
|
if i < len(bb) {
|
|
bv = bb[i]
|
|
}
|
|
if len(av) != len(bv) {
|
|
if len(av) > len(bv) {
|
|
return 1
|
|
}
|
|
return -1
|
|
}
|
|
if av != bv {
|
|
if av > bv {
|
|
return 1
|
|
}
|
|
return -1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func nextBackupSchedule() string {
|
|
data := commandOutput(8*time.Second, "pvesh", "get", "/cluster/backup", "--output-format", "json")
|
|
if data == "" {
|
|
return ""
|
|
}
|
|
var jobs []struct {
|
|
Enabled *int `json:"enabled"`
|
|
Schedule string `json:"schedule"`
|
|
}
|
|
if json.Unmarshal([]byte(data), &jobs) != nil {
|
|
return ""
|
|
}
|
|
var next []string
|
|
for _, job := range jobs {
|
|
if (job.Enabled != nil && *job.Enabled == 0) || job.Schedule == "" {
|
|
continue
|
|
}
|
|
calendar := commandOutput(5*time.Second, "systemd-analyze", "calendar", "--iterations=1", job.Schedule)
|
|
for _, line := range strings.Split(calendar, "\n") {
|
|
if strings.Contains(line, "Next elapse:") {
|
|
trimmed := strings.TrimSpace(line)
|
|
next = append(next, strings.TrimSpace(strings.TrimPrefix(trimmed, "Next elapse:")))
|
|
}
|
|
}
|
|
}
|
|
sort.Strings(next)
|
|
if len(next) > 0 {
|
|
return next[0]
|
|
}
|
|
return ""
|
|
}
|
|
func nextScrubTimer(output string) string {
|
|
for _, line := range strings.Split(output, "\n") {
|
|
if strings.Contains(strings.ToLower(line), "zfs") && strings.Contains(strings.ToLower(line), "scrub") {
|
|
fields := strings.Fields(line)
|
|
if len(fields) >= 4 {
|
|
return strings.Join(fields[:4], " ")
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func nextZFSScrubCron(path string, now time.Time) string {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
for _, line := range strings.Split(string(data), "\n") {
|
|
if !strings.Contains(line, "/usr/lib/zfs-linux/scrub") {
|
|
continue
|
|
}
|
|
fields := strings.Fields(line)
|
|
if len(fields) < 5 {
|
|
return ""
|
|
}
|
|
minute, _ := strconv.Atoi(fields[0])
|
|
hour, _ := strconv.Atoi(fields[1])
|
|
rangeParts := strings.SplitN(fields[2], "-", 2)
|
|
if len(rangeParts) != 2 {
|
|
return ""
|
|
}
|
|
from, _ := strconv.Atoi(rangeParts[0])
|
|
to, _ := strconv.Atoi(rangeParts[1])
|
|
for offset := 0; offset < 70; offset++ {
|
|
day := time.Date(now.Year(), now.Month(), now.Day()+offset, hour, minute, 0, 0, now.Location())
|
|
if day.After(now) && day.Day() >= from && day.Day() <= to && day.Weekday() == time.Sunday {
|
|
return day.Format("Mon 2006-01-02 15:04 MST")
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|