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.

Preserve measured zero guest memory and reliable guidance proofs

pulse-triage[bot]b9409a0c7451
diff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.md
index 286ce796b1..5bb69533b2 100644
--- a/docs/release-control/v6/internal/subsystems/monitoring.md
+++ b/docs/release-control/v6/internal/subsystems/monitoring.md
@@ -17,6 +17,34 @@
## Purpose
+### Guest filesystem guidance honours its caller's logger
+
+Missing-filesystem guidance uses the existing caller context logger, falling
+back to the ordinary global logger when none is set. Message, severity, scope,
+provider-text exclusions and backup precautions are unchanged. The connected
+`TestGuestFilesystemFailureGuidanceUsesObservedEvidence` captures its own
+context-tagged output without replacing a shared logger; the scheduler-health
+fixture stops the monitor it owns. This repairs the observed shared-logger race
+with an otherwise leaked alert-save worker, not a guest or backup recovery.
+
+### Measured zero guest availability stays authoritative
+
+Status/current meminfo distinguishes an explicit numeric `available: 0` from
+an omitted or null field. The measured zero stays selected, including through
+JSON copies, rather than being replaced by free/cache components or another
+memory source. Positive programmatic samples and legacy payloads without
+availability retain their existing behaviour; invalid numeric fields remain
+errors. The internal presence bit never becomes a wire field.
+
+`TestGuestStatusMemoryAvailabilityContract` covers selection and both ordinary
+collectors through direct/cluster HTTP clients, canonical views, History and
+actual threshold evaluation: measured exhaustion raises a breach, missing
+availability cannot clear it or add History, and fresh healthy evidence permits
+recovery. `TestVMStatusMemoryAvailabilityPresence` preserves the wire distinction.
+The sampled capacity, original observation time, guest command/backup-lock
+fences, QGA parser and configured thresholds are unchanged. This is synthetic
+source evidence, not reporter #2762 cause, native recovery or availability.
+
### Guest memory readings keep their own capacity
The QEMU memory selector pairs guest availability with the total from the
diff --git a/internal/monitoring/guest_filesystem_logger_test.go b/internal/monitoring/guest_filesystem_logger_test.go
new file mode 100644
index 0000000000..7b27e4c00f
--- /dev/null
+++ b/internal/monitoring/guest_filesystem_logger_test.go
@@ -0,0 +1,22 @@
+package monitoring
+
+import (
+ "bytes"
+ "context"
+ "testing"
+
+ "github.com/rs/zerolog"
+ "github.com/rs/zerolog/log"
+)
+
+func TestGuestFilesystemLoggerKeepsOrdinaryFallback(t *testing.T) {
+ if guestFilesystemLogger(context.Background()) != &log.Logger {
+ t.Fatal("ordinary filesystem guidance lost its process logger")
+ }
+ var output bytes.Buffer
+ logger := zerolog.New(&output)
+ ctx := logger.WithContext(context.Background())
+ if guestFilesystemLogger(ctx) != log.Ctx(ctx) || guestFilesystemLogger(ctx) == &log.Logger {
+ t.Fatal("filesystem guidance lost its explicit caller logger")
+ }
+}
diff --git a/internal/monitoring/guest_memory_sources.go b/internal/monitoring/guest_memory_sources.go
index 93dc7d4080..d4689ecee6 100644
--- a/internal/monitoring/guest_memory_sources.go
+++ b/internal/monitoring/guest_memory_sources.go
@@ -60,7 +60,7 @@ func deriveGuestMemInfoAvailable(memInfo *proxmox.VMMemInfo, guestRaw *VMMemoryR
memInfo.Cached == 0
switch {
- case memInfo.Available > 0 && (memInfo.Total == 0 || memInfo.Available <= memInfo.Total):
+ case memInfo.HasAvailable() && (memInfo.Total == 0 || memInfo.Available <= memInfo.Total):
return memInfo.Available, "available-field"
case memInfo.Free > 0 || memInfo.Buffers > 0 || memInfo.Cached > 0:
if availableFromUsed > 0 && missingCacheMetrics {
diff --git a/internal/monitoring/guest_memory_status_test.go b/internal/monitoring/guest_memory_status_test.go
new file mode 100644
index 0000000000..8959736ce5
--- /dev/null
+++ b/internal/monitoring/guest_memory_status_test.go
@@ -0,0 +1,201 @@
+package monitoring
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/alerts"
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ "github.com/rcourtman/pulse-go-rewrite/internal/models"
+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
+ "github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"
+)
+
+func testGuestStatusMemoryAvailabilitySelection(t *testing.T) {
+ for _, tc := range []struct {
+ name, fields, source string
+ available uint64
+ }{
+ {"zero-overrides-components", `"available":0,"free":1024,"buffers":1024,"cached":4096`, "available-field", 0},
+ {"zero-overrides-total-minus-used", `"available":0,"used":4096,"free":1024`, "available-field", 0},
+ {"zero-only", `"available":0`, "available-field", 0},
+ {"missing-with-components", `"free":1024,"buffers":1024,"cached":4096`, "derived-free-buffers-cached", 6144},
+ {"null-with-components", `"available":null,"free":1024,"buffers":1024,"cached":4096`, "derived-free-buffers-cached", 6144},
+ {"absent-is-not-exhausted", `"used":0`, "", 0},
+ {"positive-available", `"available":6144,"free":1024,"cached":4096`, "available-field", 6144},
+ {"invalid-capacity-is-not-exhausted", `"available":8193`, "", 0},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ var sample proxmox.VMMemInfo
+ if err := json.Unmarshal([]byte(`{"total":8192,`+tc.fields+`}`), &sample); err != nil {
+ t.Fatal(err)
+ }
+ for i := 0; i < 2; i++ {
+ available, source := deriveGuestMemInfoAvailable(&sample, nil)
+ if available != tc.available || source != tc.source {
+ t.Errorf("selected %d (%s), want %d (%s)", available, source, tc.available, tc.source)
+ }
+ copy, err := json.Marshal(sample)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := json.Unmarshal(copy, &sample); err != nil {
+ t.Fatal(err)
+ }
+ }
+ })
+ }
+}
+
+// Real HTTP status decoding feeds each ordinary collector and canonical views,
+// History, and threshold evaluation. No guest, backup or QGA fault is induced.
+func testGuestStatusMemoryAvailabilityPolling(t *testing.T) {
+ const gib = uint64(1024 * 1024 * 1024)
+ for _, kind := range []string{"direct", "cluster"} {
+ for _, collector := range []string{"cluster-resources", "node-list"} {
+ t.Run(kind+"/"+collector, func(t *testing.T) {
+ var phase, commands atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/status/current"):
+ // Plausible components deliberately disagree with measured
+ // availability. They are not a replacement for that field.
+ fields := fmt.Sprintf(`"available":%d,"free":%d,"buffers":%d,"cached":%d`, 3*gib, gib/2, gib/2, 2*gib)
+ switch phase.Load() {
+ case 1, 3:
+ fields = fmt.Sprintf(`"available":0,"free":%d,"buffers":%d,"cached":%d`, gib/2, gib/2, 2*gib)
+ case 2:
+ fields = `"available":null`
+ case 5:
+ fields = fmt.Sprintf(`"free":%d,"buffers":%d,"cached":%d`, gib/2, gib/2, 2*gib)
+ }
+ fmt.Fprintf(w, `{"data":{"status":"running","cpu":0.1,"agent":0,"maxmem":%d,"mem":%d,"meminfo":{"total":%d,%s}}}`, 20*gib, 20*gib, 4*gib, fields)
+ case strings.Contains(r.URL.Path, "/agent/"):
+ commands.Add(1)
+ t.Error("status availability unexpectedly queued QGA")
+ http.Error(w, "unexpected QGA read", http.StatusNotFound)
+ case strings.HasSuffix(r.URL.Path, "/version"):
+ fmt.Fprint(w, `{"data":{"version":"9.2-fixture"}}`)
+ case strings.HasSuffix(r.URL.Path, "/nodes"):
+ fmt.Fprint(w, `{"data":[{"node":"node","status":"online"}]}`)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ defer server.Close()
+ pcfg := proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: time.Second}
+ var client PVEClientInterface
+ if kind == "direct" {
+ var err error
+ client, err = proxmox.NewClient(pcfg)
+ if err != nil {
+ t.Fatal(err)
+ }
+ } else {
+ client = proxmox.NewClusterClient("status-zero", pcfg, []string{server.URL}, nil)
+ }
+ am := alerts.NewManagerWithDataDir(t.TempDir(), alerts.WithoutPersistedAlertRestore())
+ defer am.Stop()
+ acfg := am.GetConfig()
+ acfg.Enabled = true
+ acfg.GuestDefaults.Memory = &alerts.HysteresisThreshold{Trigger: 80, Clear: 75}
+ acfg.MetricTimeThresholds = map[string]map[string]int{"guest": {"memory": 0}}
+ am.UpdateConfig(acfg)
+ m := &Monitor{config: &config.Config{}, alertManager: am, rateTracker: NewRateTracker(), metricsHistory: NewMetricsHistory(32, time.Hour), guestMetadataLimiter: make(map[string]time.Time)}
+ registry := unifiedresources.NewRegistry(nil)
+ id := makeGuestID("status-zero", "node", 105)
+ previous := map[string]models.VM{}
+ build := func() models.VM {
+ t.Helper()
+ res := proxmox.ClusterResource{Type: "qemu", Node: "node", Name: "guest", VMID: 105, Status: "running", MaxMem: 20 * gib, Mem: 20 * gib, CPU: .1}
+ var vms []models.VM
+ if collector == "cluster-resources" {
+ vms = m.collectClusterVMResources(context.Background(), "status-zero", []indexedClusterResource{{resource: res, guestID: id}}, client, previous, nil)
+ } else {
+ vms, _ = m.pollNodeVMsWithClusterResourceBuilder(context.Background(), "status-zero", "node", []proxmox.VM{{VMID: 105, Name: "guest", Status: "running", MaxMem: res.MaxMem, Mem: res.Mem, CPU: .1}}, client, previous, nil)
+ }
+ if len(vms) != 1 {
+ t.Fatalf("collector lost VM: %v", vms)
+ }
+ vm := vms[0]
+ m.recordGuestMetrics(vms, nil, time.Now().Add(-time.Second))
+ registry.IngestSnapshot(models.StateSnapshot{VMs: vms})
+ views := registry.VMs()
+ if len(views) != 1 {
+ t.Fatalf("canonical view lost VM: %v", views)
+ }
+ view := views[0]
+ evidence := view.MemoryEvidence(time.Now())
+ if vm.Memory.HasKnownUsage() {
+ if view.MemoryTotal() != vm.Memory.Total || view.MemoryUsed() != vm.Memory.Used || view.MemoryPercent() != vm.Memory.Usage || (vm.Memory.Observation.State == "current" && !evidence.PressureKnown) {
+ t.Errorf("selected measurement changed at canonical boundary: %+v", evidence)
+ }
+ } else if evidence.Available || evidence.PressureKnown {
+ t.Errorf("missing measurement became pressure: %+v", evidence)
+ }
+ previous[id] = previousVMFromView(view)
+ return vm
+ }
+ assertCurrent := func(vm models.VM, want float64, source string) {
+ t.Helper()
+ if !vm.Memory.HasKnownUsage() || vm.Memory.Total != 4*int64(gib) || vm.Memory.Usage != want || vm.Memory.Observation.State != "current" || vm.Memory.Observation.Source != source {
+ t.Errorf("current sample lost zero/presence/capacity: %+v", vm.Memory)
+ }
+ }
+ assertCurrent(build(), 25, "available-field")
+ if len(am.GetActiveAlerts()) != 0 {
+ t.Error("healthy observation alerted")
+ }
+ phase.Store(1)
+ pressure := build()
+ assertCurrent(pressure, 100, "available-field")
+ if pressure.Memory.Used != pressure.Memory.Total || pressure.Memory.Free != 0 || pressure.Memory.Cache != 0 {
+ t.Errorf("exhaustion retained speculative cache: %+v", pressure.Memory)
+ }
+ active := am.GetActiveAlerts()
+ if len(active) != 1 || active[0].Type != "memory" || active[0].Value != 100 {
+ t.Errorf("full pressure was not alerted: %+v", active)
+ }
+ phase.Store(2)
+ unknown := build()
+ if unknown.Memory.Observation.State == "current" ||
+ (unknown.Memory.HasKnownUsage() && (unknown.Memory.Observation.State != "last-known" || unknown.Memory.Used != pressure.Memory.Used || unknown.Memory.Total != pressure.Memory.Total || !unknown.Memory.Observation.ObservedAt.Equal(pressure.Memory.Observation.ObservedAt))) {
+ t.Errorf("null availability invented or renewed usage: %+v", unknown.Memory)
+ }
+ if len(am.GetActiveAlerts()) != 1 {
+ t.Error("missing availability cleared real breach")
+ }
+ phase.Store(3)
+ assertCurrent(build(), 100, "available-field")
+ phase.Store(4)
+ assertCurrent(build(), 25, "available-field")
+ if len(am.GetActiveAlerts()) != 0 {
+ t.Error("real healthy observation did not recover breach")
+ }
+ phase.Store(5)
+ assertCurrent(build(), 25, "derived-free-buffers-cached")
+ points := m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)
+ want := []float64{25, 100, 100, 25, 25}
+ if len(points) != len(want) {
+ t.Fatalf("History lost measurement or gained missing sample: %+v", points)
+ }
+ for i, point := range points {
+ if point.Value != want[i] {
+ t.Errorf("History[%d] = %v, want %v", i, point.Value, want[i])
+ }
+ }
+ if commands.Load() != 0 {
+ t.Error("status-only collection gained guest commands")
+ }
+ })
+ }
+ }
+}
diff --git a/internal/monitoring/memory_trust_characterization_test.go b/internal/monitoring/memory_trust_characterization_test.go
index d7e87fb800..2f6faa63c3 100644
--- a/internal/monitoring/memory_trust_characterization_test.go
+++ b/internal/monitoring/memory_trust_characterization_test.go
@@ -1198,3 +1198,8 @@ func TestBackupLockMemoryTrustKeepsNativeEvidenceWithoutAgentReads(t *testing.T)
})
}
}
+
+func TestGuestStatusMemoryAvailabilityContract(t *testing.T) {
+ testGuestStatusMemoryAvailabilitySelection(t)
+ testGuestStatusMemoryAvailabilityPolling(t)
+}
diff --git a/internal/monitoring/monitor_health_test.go b/internal/monitoring/monitor_health_test.go
index a421891046..ed2f66470b 100644
--- a/internal/monitoring/monitor_health_test.go
+++ b/internal/monitoring/monitor_health_test.go
@@ -25,6 +25,7 @@ func TestSchedulerHealth_EnhancedResponse(t *testing.T) {
if err != nil {
t.Fatalf("unexpected error creating monitor: %v", err)
}
+ t.Cleanup(monitor.Stop)
instanceKey := schedulerKey(InstanceTypePVE, "pve-a")
monitor.pollStatusMap[instanceKey] = &pollStatus{
diff --git a/internal/monitoring/monitor_pve_guest_builders.go b/internal/monitoring/monitor_pve_guest_builders.go
index f56dc2ff0c..37899bdbe8 100644
--- a/internal/monitoring/monitor_pve_guest_builders.go
+++ b/internal/monitoring/monitor_pve_guest_builders.go
@@ -10,6 +10,7 @@ import (
"github.com/rcourtman/pulse-go-rewrite/internal/models"
"github.com/rcourtman/pulse-go-rewrite/pkg/fsfilters"
"github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"
+ "github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
@@ -640,20 +641,30 @@ func (m *Monitor) fetchVMFSInfo(ctx context.Context, instanceName string, res pr
return nil, reason, false
}
reason := classifyGuestAgentDiskStatusError(err)
- logVMFilesystemUnavailable(instanceName, res, reason)
+ logVMFilesystemUnavailable(ctx, instanceName, res, reason)
return nil, classifyGuestAgentDiskStatusError(err), false
}
if len(fsInfo) == 0 {
- logVMFilesystemUnavailable(instanceName, res, "no-filesystems")
+ logVMFilesystemUnavailable(ctx, instanceName, res, "no-filesystems")
return nil, "no-filesystems", false
}
return fsInfo, "", true
}
+// Keep ordinary process logging when no context logger is installed. Tests and
+// callers with an explicit logger can own their output without global mutation.
+func guestFilesystemLogger(ctx context.Context) *zerolog.Logger {
+ logger := log.Ctx(ctx)
+ if logger.GetLevel() == zerolog.Disabled {
+ return &log.Logger
+ }
+ return logger
+}
+
// Missing optional readings do not establish a need to activate/restart QGA,
// change backup policy, or reconfigure a shared Proxmox role. Keep this guidance
// independent of provider error text and the guest's operating system.
-func logVMFilesystemUnavailable(instanceName string, res proxmox.ClusterResource, reason string) {
+func logVMFilesystemUnavailable(ctx context.Context, instanceName string, res proxmox.ClusterResource, reason string) {
message := "Guest filesystem query failed; check disk usage inside the guest. Keep existing guest-agent and backup settings."
switch reason {
case "agent-not-running":
@@ -665,7 +676,7 @@ func logVMFilesystemUnavailable(instanceName string, res proxmox.ClusterResource
case "no-filesystems":
message = "Guest agent returned no filesystem readings; check disk usage inside the guest. Keep existing guest-agent and backup settings."
}
- log.Info().
+ guestFilesystemLogger(ctx).Info().
Str("instance", instanceName).
Str("vm", res.Name).
Int("vmid", res.VMID).
diff --git a/internal/monitoring/monitor_pve_guest_lxc_test.go b/internal/monitoring/monitor_pve_guest_lxc_test.go
index bdca67a7d6..6f7492e721 100644
--- a/internal/monitoring/monitor_pve_guest_lxc_test.go
+++ b/internal/monitoring/monitor_pve_guest_lxc_test.go
@@ -20,7 +20,6 @@ import (
agentshost "github.com/rcourtman/pulse-go-rewrite/pkg/agents/host"
"github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"
"github.com/rs/zerolog"
- "github.com/rs/zerolog/log"
)
func TestGuestMemoryCarryForwardExpiryContract(t *testing.T) {
@@ -934,12 +933,11 @@ func TestGuestFilesystemFailureGuidanceUsesObservedEvidence(t *testing.T) {
t.Fatal(err)
}
var output bytes.Buffer
- previousLogger := log.Logger
- log.Logger = zerolog.New(&output)
- defer func() { log.Logger = previousLogger }()
+ logger := zerolog.New(&output).With().Str("receipt_scope", "fixture").Logger()
+ ctx := logger.WithContext(context.Background())
m := &Monitor{guestAgentFSInfoTimeout: time.Second, guestAgentRetries: 2}
res := proxmox.ClusterResource{Node: "node", VMID: 105, Name: "fixture-vm", Type: "qemu", Status: "running", MaxDisk: 1000}
- total, used, free, usage, disks, fromAgent, reason := m.updateVMDisksFromGuestAgentFSInfo(context.Background(), "fixture-instance", res, client, 1000, 0, 0)
+ total, used, free, usage, disks, fromAgent, reason := m.updateVMDisksFromGuestAgentFSInfo(ctx, "fixture-instance", res, client, 1000, 0, 0)
if reason != tc.reason || fromAgent || usage != -1 || total != 1000 || used != 0 || free != 1000 || disks != nil {
t.Errorf("unavailable reading = %d/%d/%d/%v/%v/%t/%q", total, used, free, usage, disks, fromAgent, reason)
}
@@ -980,7 +978,7 @@ func TestGuestFilesystemFailureGuidanceUsesObservedEvidence(t *testing.T) {
}
guidance++
message, _ := event["message"].(string)
- if !tc.logged || event["level"] != "info" || event["instance"] != "fixture-instance" || event["vm"] != "fixture-vm" || event["reason"] != tc.reason || !strings.HasPrefix(message, tc.message) {
+ if !tc.logged || event["receipt_scope"] != "fixture" || event["level"] != "info" || event["instance"] != "fixture-instance" || event["vm"] != "fixture-vm" || event["reason"] != tc.reason || !strings.HasPrefix(message, tc.message) {
t.Errorf("observed-evidence guidance lost: %v", event)
}
if !strings.Contains(message, "guest-agent and backup settings") {
diff --git a/pkg/proxmox/client.go b/pkg/proxmox/client.go
index 4b0b6568fc..9d80472c11 100644
--- a/pkg/proxmox/client.go
+++ b/pkg/proxmox/client.go
@@ -2649,6 +2649,47 @@ type VMMemInfo struct {
Buffers uint64 `json:"buffers,omitempty"`
Cached uint64 `json:"cached,omitempty"`
Shared uint64 `json:"shared,omitempty"`
+
+ availablePresent bool // Measured zero must not become missing availability.
+}
+
+// HasAvailable distinguishes a guest's measured zero availability from older
+// status payloads without that field. Nonzero programmatically built samples
+// retain their existing meaning.
+func (m VMMemInfo) HasAvailable() bool {
+ return m.availablePresent || m.Available > 0
+}
+
+func (m *VMMemInfo) UnmarshalJSON(data []byte) error {
+ type plain VMMemInfo
+ var decoded plain
+ wire := struct {
+ *plain
+ Available *uint64 `json:"available"`
+ }{plain: &decoded}
+ if err := json.Unmarshal(data, &wire); err != nil {
+ return err
+ }
+ if wire.Available != nil {
+ decoded.Available = *wire.Available
+ decoded.availablePresent = true
+ }
+ *m = VMMemInfo(decoded)
+ return nil
+}
+
+// Keep explicit zero through status copies/JSON round trips without inventing
+// an available field for legacy payloads. Internal presence is not a wire field.
+func (m VMMemInfo) MarshalJSON() ([]byte, error) {
+ type plain VMMemInfo
+ var available *uint64
+ if m.HasAvailable() {
+ available = &m.Available
+ }
+ return json.Marshal(struct {
+ plain
+ Available *uint64 `json:"available,omitempty"`
+ }{plain: plain(m), Available: available})
}
// VMBalloonInfo describes guest memory details returned by status/current when
diff --git a/pkg/proxmox/guest_memory_status_test.go b/pkg/proxmox/guest_memory_status_test.go
new file mode 100644
index 0000000000..1cc39cd879
--- /dev/null
+++ b/pkg/proxmox/guest_memory_status_test.go
@@ -0,0 +1,76 @@
+package proxmox
+
+import (
+ "encoding/json"
+ "testing"
+)
+
+// These tests also run unchanged against the parent: the wire distinction is
+// the requirement, rather than the new implementation's private presence bit.
+func testVMMemInfoAvailabilityRoundTrip(t *testing.T) {
+ for _, tc := range []struct {
+ name, wire string
+ present bool
+ available uint64
+ }{
+ {"measured-zero", `{"total":8192,"available":0,"free":1024,"cached":4096}`, true, 0},
+ {"positive", `{"total":8192,"available":6144}`, true, 6144},
+ {"missing", `{"total":8192,"free":1024,"cached":4096}`, false, 0},
+ {"null-is-not-zero", `{"total":8192,"available":null,"free":1024,"cached":4096}`, false, 0},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ var sample VMMemInfo
+ if err := json.Unmarshal([]byte(tc.wire), &sample); err != nil {
+ t.Fatal(err)
+ }
+ for i := 0; i < 3; i++ {
+ encoded, err := json.Marshal(sample)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var fields map[string]json.RawMessage
+ if err := json.Unmarshal(encoded, &fields); err != nil {
+ t.Fatal(err)
+ }
+ _, present := fields["available"]
+ if present != tc.present || sample.Available != tc.available || sample.Total != 8192 {
+ t.Errorf("round trip %d: availability presence/value/capacity lost: %s", i, encoded)
+ }
+ if err := json.Unmarshal(encoded, &sample); err != nil {
+ t.Fatal(err)
+ }
+ }
+ })
+ }
+}
+
+func testVMMemInfoAvailabilityRejectsInvalidNumbers(t *testing.T) {
+ for _, value := range []string{`-1`, `0.5`, `"0"`, `true`, `{}`, `[]`, `18446744073709551616`} {
+ t.Run(value, func(t *testing.T) {
+ var sample VMMemInfo
+ if err := json.Unmarshal([]byte(`{"total":8192,"available":`+value+`}`), &sample); err == nil {
+ t.Fatal("invalid availability became a valid sample")
+ }
+ })
+ }
+}
+
+func testVMMemInfoAvailabilityPresenceDoesNotLeakAcrossDecode(t *testing.T) {
+ var sample VMMemInfo
+ for _, wire := range []string{`{"total":8192,"available":0}`, `{"total":4096}`, `{"total":2048,"available":null}`} {
+ if err := json.Unmarshal([]byte(wire), &sample); err != nil {
+ t.Fatal(err)
+ }
+ encoded, err := json.Marshal(sample)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var fields map[string]json.RawMessage
+ json.Unmarshal(encoded, &fields)
+ _, present := fields["available"]
+ want := wire == `{"total":8192,"available":0}`
+ if present != want {
+ t.Errorf("presence survived unrelated sample: %s", encoded)
+ }
+ }
+}
diff --git a/pkg/proxmox/io_counters_test.go b/pkg/proxmox/io_counters_test.go
index d36e7fe244..c914db7a61 100644
--- a/pkg/proxmox/io_counters_test.go
+++ b/pkg/proxmox/io_counters_test.go
@@ -246,3 +246,10 @@ func TestGuestAgentTransportDeferralPreservesLiveCounterReceipts(t *testing.T) {
})
}
}
+
+// The same ordinary status decoder also preserves memory availability presence.
+func TestVMStatusMemoryAvailabilityPresence(t *testing.T) {
+ t.Run("round-trip", testVMMemInfoAvailabilityRoundTrip)
+ t.Run("invalid-numbers", testVMMemInfoAvailabilityRejectsInvalidNumbers)
+ t.Run("reused-decode", testVMMemInfoAvailabilityPresenceDoesNotLeakAcrossDecode)
+}