Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

9.2 KB
Raw Blame
package hostagent

import (
	"context"
	"os"
	"regexp"
	"strings"
	"time"
)

var unraidVersionPattern = regexp.MustCompile(`\b\d+(?:\.\d+)+(?:[-+._][A-Za-z0-9]+)*\b|\b\d+\b`)
var proxmoxPVEVersionPattern = regexp.MustCompile(`(?i)\bpve-manager/([^/\s]+)`)
var linuxOSReleaseIDPattern = regexp.MustCompile(`^[a-z0-9._-]+$`)

const proxmoxPVEOSName = "Proxmox VE"
const proxmoxPVEVersionCommandTimeout = 10 * time.Second

func resolveHostOSIdentity(collector SystemCollector, osName, osVersion string) (string, string) {
	currentName := strings.TrimSpace(osName)
	currentVersion := strings.TrimSpace(osVersion)

	if collector == nil || collector.GOOS() != "linux" {
		return currentName, currentVersion
	}

	if name, version, ok := detectSynologyOSIdentity(collector); ok {
		return resolvedDetectedHostOSIdentity(name, version, currentVersion, true)
	}

	if name, version, ok := detectQNAPOSIdentity(collector); ok {
		return resolvedDetectedHostOSIdentity(name, version, currentVersion, true)
	}

	if name, version, ok := detectUnraidOSIdentity(collector); ok {
		return resolvedDetectedHostOSIdentity(name, version, currentVersion, true)
	}

	if name, version, ok := detectProxmoxVEOSIdentity(collector); ok {
		return resolvedDetectedHostOSIdentity(name, version, currentVersion, false)
	}

	// Package-presence heuristics can misidentify ordinary distributions: for
	// example, Debian can install raspi-config without becoming Raspbian (#2854).
	// Keep appliance detection above authoritative distro metadata, and retain
	// the collector's version (which can be more precise than VERSION_ID).
	if name := detectLinuxDistributionOSName(collector); name != "" {
		return name, currentVersion
	}

	return currentName, currentVersion
}

func detectLinuxDistributionOSName(collector SystemCollector) string {
	data, err := collector.ReadFile("/etc/os-release")
	if os.IsNotExist(err) {
		data, err = collector.ReadFile("/usr/lib/os-release")
	}
	if err != nil {
		return ""
	}

	// os-release is data, not a shell script. Only its machine-readable ID is
	// needed; do not evaluate expansions or substitute NAME/ID_LIKE (a family).
	// /etc takes precedence as a whole, even when its ID is unavailable.
	id := ""
	for _, line := range strings.Split(string(data), "\n") {
		key, value, ok := strings.Cut(strings.TrimSpace(line), "=")
		if !ok || strings.TrimSpace(key) != "ID" {
			continue
		}
		value = strings.TrimSpace(value)
		if len(value) >= 2 && (value[0] == '"' || value[0] == '\'') && value[len(value)-1] == value[0] {
			value = value[1 : len(value)-1]
		}
		if !linuxOSReleaseIDPattern.MatchString(value) {
			return ""
		}
		id = value
	}
	return id
}

func resolvedDetectedHostOSIdentity(name, version, currentVersion string, allowVersionFallback bool) (string, string) {
	version = strings.TrimSpace(version)
	if version == "" && allowVersionFallback {
		version = currentVersion
	}
	return strings.TrimSpace(name), strings.TrimSpace(version)
}

func detectSynologyOSIdentity(collector SystemCollector) (string, string, bool) {
	hasSynologyDir := false
	if _, err := collector.Stat("/usr/syno"); err == nil {
		hasSynologyDir = true
	}

	for _, path := range []string{"/etc.defaults/VERSION", "/etc/VERSION"} {
		data, err := collector.ReadFile(path)
		if err != nil || len(data) == 0 {
			continue
		}

		values := parseAssignmentConfig(string(data))
		if len(values) == 0 {
			continue
		}
		if !hasSynologyDir && !looksLikeSynologyVersionFile(values) {
			continue
		}

		version := composeSynologyVersion(values)
		return "Synology DSM", version, true
	}

	return "", "", false
}

func composeSynologyVersion(values map[string]string) string {
	version := strings.TrimSpace(values["productversion"])
	if version == "" {
		major := strings.TrimSpace(values["majorversion"])
		minor := strings.TrimSpace(values["minorversion"])
		switch {
		case major != "" && minor != "":
			version = major + "." + minor
		case major != "":
			version = major
		case minor != "":
			version = minor
		}
	}

	build := strings.TrimSpace(values["buildnumber"])
	if build != "" && !strings.Contains(version, build) {
		if version != "" {
			version += "-" + build
		} else {
			version = build
		}
	}

	smallfix := strings.TrimSpace(values["smallfixnumber"])
	if smallfix != "" && smallfix != "0" {
		if version != "" {
			version += " Update " + smallfix
		} else {
			version = smallfix
		}
	}

	return strings.TrimSpace(version)
}

func looksLikeSynologyVersionFile(values map[string]string) bool {
	if values["majorversion"] != "" || values["minorversion"] != "" || values["buildnumber"] != "" || values["productversion"] != "" {
		return true
	}

	hints := strings.ToLower(strings.Join([]string{
		values["product"],
		values["unique"],
		values["buildphase"],
	}, " "))
	return strings.Contains(hints, "synology") || strings.Contains(hints, "dsm") || strings.Contains(hints, "diskstation")
}

func detectQNAPOSIdentity(collector SystemCollector) (string, string, bool) {
	for _, path := range []string{"/etc/config/uLinux.conf", "/etc/default_config/uLinux.conf"} {
		data, err := collector.ReadFile(path)
		if err != nil || len(data) == 0 {
			continue
		}

		values := parseAssignmentConfig(string(data))
		if len(values) == 0 {
			continue
		}

		name := "QNAP QTS"
		hintFields := strings.ToLower(strings.Join([]string{
			values["display_name"],
			values["platform"],
			values["system_name"],
			values["version"],
		}, " "))
		if strings.Contains(hintFields, "quts") {
			name = "QNAP QuTS"
		}
		return name, strings.TrimSpace(values["version"]), true
	}

	if _, err := collector.Stat("/etc/config/qpkg.conf"); err == nil {
		return "QNAP QTS", "", true
	}
	if _, err := collector.Stat("/sbin/getcfg"); err == nil {
		return "QNAP QTS", "", true
	}

	return "", "", false
}

func detectUnraidOSIdentity(collector SystemCollector) (string, string, bool) {
	data, err := collector.ReadFile(hostAgentUnraidVersionPath)
	if err != nil {
		if _, statErr := collector.Stat(hostAgentUnraidVersionPath); statErr == nil {
			return "Unraid", "", true
		}
		return detectUnraidOSReleaseIdentity(collector)
	}

	version := cleanUnraidVersion(string(data))
	return "Unraid", version, true
}

func detectProxmoxVEOSIdentity(collector SystemCollector) (string, string, bool) {
	hasPVE := false
	if _, err := collector.Stat("/etc/pve"); err == nil {
		hasPVE = true
	}

	pveVersionPath, err := collector.LookPath("pveversion")
	if err == nil {
		hasPVE = true
	}

	if !hasPVE {
		if _, err := collector.LookPath("pvesh"); err != nil {
			return "", "", false
		}
	}

	version := ""
	if packageVersion := detectProxmoxVEPackageVersion(collector); packageVersion != "" {
		version = packageVersion
	} else if pveVersionPath != "" {
		ctx, cancel := context.WithTimeout(context.Background(), proxmoxPVEVersionCommandTimeout)
		if output, err := collector.CommandCombinedOutput(ctx, pveVersionPath); err == nil {
			version = cleanProxmoxPVEVersion(output)
		}
		cancel()
	}

	return proxmoxPVEOSName, version, true
}

func detectProxmoxVEPackageVersion(collector SystemCollector) string {
	dpkgQueryPath, err := collector.LookPath("dpkg-query")
	if err != nil || dpkgQueryPath == "" {
		return ""
	}

	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	output, err := collector.CommandCombinedOutput(ctx, dpkgQueryPath, "-W", "-f=${Version}", "pve-manager")
	if err != nil {
		return ""
	}
	return cleanProxmoxPVEPackageVersion(output)
}

func cleanProxmoxPVEPackageVersion(raw string) string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return ""
	}
	if strings.ContainsAny(raw, "\r\n\t ") {
		return ""
	}
	return raw
}

func cleanProxmoxPVEVersion(raw string) string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return ""
	}
	if match := proxmoxPVEVersionPattern.FindStringSubmatch(raw); len(match) == 2 {
		return strings.TrimSpace(match[1])
	}
	return ""
}

func detectUnraidOSReleaseIdentity(collector SystemCollector) (string, string, bool) {
	data, err := collector.ReadFile("/etc/os-release")
	if err != nil || len(data) == 0 {
		return "", "", false
	}

	values := parseAssignmentConfig(string(data))
	hints := strings.ToLower(strings.Join([]string{
		values["id"],
		values["name"],
		values["pretty_name"],
	}, " "))
	if !strings.Contains(hints, "unraid") {
		return "", "", false
	}

	version := strings.TrimSpace(values["version_id"])
	if version == "" {
		version = cleanUnraidVersion(values["version"])
	}
	return "Unraid", version, true
}

func cleanUnraidVersion(raw string) string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return ""
	}

	for _, line := range strings.Split(raw, "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
		if match := unraidVersionPattern.FindString(line); match != "" {
			return match
		}
	}

	return ""
}

func parseAssignmentConfig(content string) map[string]string {
	parsed := make(map[string]string)

	for _, line := range strings.Split(content, "\n") {
		line = strings.TrimSpace(line)
		if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, ";") || strings.HasPrefix(line, "[") {
			continue
		}

		idx := strings.IndexRune(line, '=')
		if idx <= 0 {
			continue
		}

		key := strings.ToLower(strings.TrimSpace(line[:idx]))
		value := strings.TrimSpace(line[idx+1:])
		value = strings.Trim(value, `"'`)
		if key == "" || value == "" {
			continue
		}

		parsed[key] = value
	}

	return parsed
}