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.

Require complete Proxmox guest status observations

pulse-triage[bot]0d07a527244e
diff --git a/internal/monitoring/guest_status_http_test.go b/internal/monitoring/guest_status_http_test.go
new file mode 100644
index 0000000000..d9d109a7e9
--- /dev/null
+++ b/internal/monitoring/guest_status_http_test.go
@@ -0,0 +1,232 @@
+package monitoring
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "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"
+)
+
+// The independent control-plane observer must not turn an unfinished or
+// contradictory status reply into proof of an action's outcome. No action,
+// guest-agent operation or native failure is executed by these HTTP fixtures.
+func TestGuestStatusHTTPActionObservation(t *testing.T) {
+ for _, clientKind := range []string{"direct", "cluster"} {
+ for _, kind := range []string{"qemu", "lxc"} {
+ for _, rejection := range []string{"prefix", "truncated", "foreign", "conflicting-error"} {
+ t.Run(clientKind+"/"+kind+"/"+rejection, func(t *testing.T) {
+ var phase, statuses, commands atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/nodes"):
+ fmt.Fprint(w, `{"data":[{"node":"node","status":"online"}]}`)
+ case strings.HasSuffix(r.URL.Path, "/status/current"):
+ statuses.Add(1)
+ body := `{"data":{"status":"running","uptime":42,"vmid":105}}`
+ if phase.Load() == 1 {
+ switch rejection {
+ case "prefix":
+ body += ` {"data":{"status":"stopped"}}`
+ case "truncated":
+ w.Header().Set("Content-Length", fmt.Sprint(len(body)+100))
+ case "foreign":
+ body = `{"data":{"status":"running","uptime":42,"vmid":106}}`
+ case "conflicting-error":
+ body = `{"data":{"status":"running","uptime":42},"errors":{"reason":"fixture-private-detail"}}`
+ }
+ } else if phase.Load() == 2 {
+ body = `{"data":{"status":"stopped","uptime":0}}`
+ }
+ fmt.Fprint(w, body)
+ default:
+ commands.Add(1)
+ t.Errorf("unexpected non-status operation: %s", r.URL.Path)
+ http.NotFound(w, r)
+ }
+ }))
+ defer server.Close()
+ cfg := proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: guestPollFixtureHangGuard}
+ var client PVEClientInterface
+ if clientKind == "direct" {
+ var err error
+ client, err = proxmox.NewClient(cfg)
+ if err != nil {
+ t.Fatal(err)
+ }
+ } else {
+ client = proxmox.NewClusterClient("status-observer", cfg, []string{server.URL}, nil)
+ }
+ m := &Monitor{pveClients: map[string]PVEClientInterface{"status-observer": client}}
+ for step := int32(0); step < 3; step++ {
+ phase.Store(step)
+ before := statuses.Load()
+ observation, err := m.ObserveProxmoxGuest(context.Background(), "status-observer", "node", 105, kind)
+ if step == 1 {
+ if err == nil || observation != (ProxmoxGuestObservation{}) {
+ t.Errorf("unverified action observation: %+v err=%v", observation, err)
+ }
+ if err != nil && strings.Contains(err.Error(), "fixture-private-detail") {
+ t.Error("response body escaped into observer error")
+ }
+ } else {
+ state, uptime := "running", uint64(42)
+ if step == 2 {
+ state, uptime = "stopped", 0
+ }
+ if err != nil || observation.Status != state || observation.Uptime != uptime || observation.ObservedAt.IsZero() {
+ t.Errorf("valid independent observation lost: %+v err=%v", observation, err)
+ }
+ }
+ if statuses.Load()-before != 1 {
+ t.Errorf("status admission added retry: %d", statuses.Load()-before)
+ }
+ }
+ if commands.Load() != 0 {
+ t.Error("observer added guest operations")
+ }
+ })
+ }
+ }
+ }
+}
+
+type guestStatusHTTPFrame struct {
+ Phase string `json:"phase"`
+ VM models.VM `json:"vm"`
+ Resources json.RawMessage `json:"resources"`
+ MemoryHistory []MetricPoint `json:"memoryHistory"`
+}
+
+func guestStatusHTTPMonitoringJourney(t *testing.T, clientKind, collector, rejection string) []guestStatusHTTPFrame {
+ t.Helper()
+ const gib = uint64(1024 * 1024 * 1024)
+ var phase, commands atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/nodes"):
+ fmt.Fprint(w, `{"data":[{"node":"node","status":"online"}]}`)
+ case strings.HasSuffix(r.URL.Path, "/status/current"):
+ available := uint64(0)
+ if phase.Load() > 0 {
+ available = 3 * gib
+ }
+ body := fmt.Sprintf(`{"data":{"status":"running","agent":0,"maxmem":%d,"mem":%d,"meminfo":{"total":%d,"available":%d},"uptime":42}}`, 8*gib, 8*gib, 4*gib, available)
+ if phase.Load() == 1 || phase.Load() == 2 {
+ switch rejection {
+ case "prefix":
+ body += ` {"data":null}`
+ case "truncated":
+ w.Header().Set("Content-Length", fmt.Sprint(len(body)+100))
+ case "missing":
+ body = `{}`
+ case "conflicting-error":
+ body = body[:len(body)-1] + `,"errors":{"message":"fixture-private-detail"}}`
+ }
+ }
+ fmt.Fprint(w, body)
+ default:
+ commands.Add(1)
+ t.Errorf("status-only fixture issued extra operation: %s", r.URL.Path)
+ http.NotFound(w, r)
+ }
+ }))
+ defer server.Close()
+ cfg := proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: guestPollFixtureHangGuard}
+ var client PVEClientInterface
+ if clientKind == "direct" {
+ var err error
+ client, err = proxmox.NewClient(cfg)
+ if err != nil {
+ t.Fatal(err)
+ }
+ } else {
+ client = proxmox.NewClusterClient("status-integrity", cfg, []string{server.URL}, nil)
+ }
+ m := &Monitor{config: &config.Config{}, rateTracker: NewRateTracker(), metricsHistory: NewMetricsHistory(32, time.Hour), guestMetadataLimiter: make(map[string]time.Time)}
+ registry := unifiedresources.NewRegistry(nil)
+ id := makeGuestID("status-integrity", "node", 105)
+ previous := map[string]models.VM{}
+ var frames []guestStatusHTTPFrame
+ for step, name := range []string{"accepted-pressure", "unread-status", "repeated-unread", "recovered"} {
+ phase.Store(int32(step))
+ ctx, cancel := context.WithTimeout(context.Background(), guestPollFixtureHangGuard)
+ cycleStart := time.Now()
+ res := proxmox.ClusterResource{Type: "qemu", Node: "node", VMID: 105, Name: "status-integrity-guest", Status: "running", CPU: .2 + float64(step)/10, MaxMem: 8 * gib, Mem: 8 * gib, MaxDisk: gib}
+ var vms []models.VM
+ if collector == "cluster" {
+ vms = m.collectClusterVMResources(ctx, "status-integrity", []indexedClusterResource{{resource: res, guestID: id}}, client, previous, nil)
+ } else {
+ vms, _ = m.pollNodeVMsWithClusterResourceBuilder(ctx, "status-integrity", "node", []proxmox.VM{{VMID: 105, Name: res.Name, Status: res.Status, CPU: res.CPU, MaxMem: res.MaxMem, Mem: res.Mem, MaxDisk: res.MaxDisk}}, client, previous, nil)
+ }
+ cancel()
+ if len(vms) != 1 {
+ t.Fatalf("collector lost independently listed guest: %d", len(vms))
+ }
+ vm := vms[0]
+ m.recordGuestMetrics(vms, nil, cycleStart)
+ registry.IngestSnapshot(models.StateSnapshot{VMs: vms})
+ views := registry.VMs()
+ if len(views) != 1 {
+ t.Fatal("canonical projection lost guest")
+ }
+ if vm.CPU != res.CPU || vm.Status != "running" {
+ t.Error("status rejection stopped independent guest telemetry")
+ }
+ switch step {
+ case 0:
+ if vm.Memory.Usage != 100 || vm.Memory.Observation.State != "current" || vm.Memory.Observation.Source != "available-field" {
+ t.Fatalf("initial pressure did not establish evidence: %+v", vm.Memory)
+ }
+ case 1, 2:
+ original := frames[0].VM.Memory
+ if vm.Memory.Usage != 100 || vm.Memory.Observation.State != "last-known" || !vm.Memory.Observation.ObservedAt.Equal(original.Observation.ObservedAt) {
+ t.Errorf("rejected status invented/renewed healthy memory: %+v", vm.Memory)
+ }
+ if views[0].MemoryEvidence(time.Now()).PressureKnown {
+ t.Error("retained memory became current pressure")
+ }
+ if len(m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)) != 1 {
+ t.Error("rejected status added current memory History")
+ }
+ case 3:
+ if vm.Memory.Usage != 25 || vm.Memory.Observation.State != "current" {
+ t.Errorf("valid later status did not recover: %+v", vm.Memory)
+ }
+ }
+ front := m.buildBroadcastFrontendStateFromSnapshot(models.StateSnapshot{VMs: vms}, m.mockModeFence.begin())
+ wire, err := json.Marshal(front.Resources)
+ if err != nil {
+ t.Fatal(err)
+ }
+ frames = append(frames, guestStatusHTTPFrame{Phase: name, VM: vm, Resources: wire, MemoryHistory: m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)})
+ previous[id] = previousVMFromView(views[0])
+ }
+ if commands.Load() != 0 {
+ t.Error("status rejection queued a guest operation")
+ }
+ history := m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)
+ if len(history) != 2 || history[0].Value != 100 || history[1].Value != 25 {
+ t.Errorf("History accepted rejected reading or lost recovery: %+v", history)
+ }
+ return frames
+}
+
+func TestGuestStatusHTTPMonitoringContract(t *testing.T) {
+ for _, client := range []string{"direct", "cluster"} {
+ for _, collector := range []string{"cluster", "node"} {
+ for _, rejection := range []string{"prefix", "truncated", "missing", "conflicting-error"} {
+ t.Run(client+"/"+collector+"/"+rejection, func(t *testing.T) { guestStatusHTTPMonitoringJourney(t, client, collector, rejection) })
+ }
+ }
+ }
+}
diff --git a/pkg/proxmox/client.go b/pkg/proxmox/client.go
index c3b27c202c..82f2438cb8 100644
--- a/pkg/proxmox/client.go
+++ b/pkg/proxmox/client.go
@@ -2479,18 +2479,12 @@ func (c *Client) GetVMStatus(ctx context.Context, node string, vmid int) (*VMSta
if err != nil {
return nil, err
}
- defer resp.Body.Close()
-
- var result struct {
- Data VMStatus `json:"data"`
- }
-
- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+ status, err := readGuestStatus[VMStatus](resp, vmid)
+ if err != nil {
return nil, err
}
-
- result.Data.ObservedAt = time.Now().UTC()
- return &result.Data, nil
+ status.ObservedAt = time.Now().UTC()
+ return status, nil
}
// GetContainerStatus returns detailed container status using real-time endpoint
@@ -2499,18 +2493,12 @@ func (c *Client) GetContainerStatus(ctx context.Context, node string, vmid int)
if err != nil {
return nil, err
}
- defer resp.Body.Close()
-
- var result struct {
- Data Container `json:"data"`
- }
-
- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+ status, err := readGuestStatus[Container](resp, vmid)
+ if err != nil {
return nil, err
}
-
- result.Data.ObservedAt = time.Now().UTC()
- return &result.Data, nil
+ status.ObservedAt = time.Now().UTC()
+ return status, nil
}
// ClusterResource represents a resource from /cluster/resources
diff --git a/pkg/proxmox/guest_status_response.go b/pkg/proxmox/guest_status_response.go
new file mode 100644
index 0000000000..73d231101c
--- /dev/null
+++ b/pkg/proxmox/guest_status_response.go
@@ -0,0 +1,67 @@
+package proxmox
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "net/http"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+)
+
+// Status supports both monitoring samples and independent action observations.
+// A decodable prefix is not a completed read; never include its body in errors.
+var errInvalidGuestStatusResponse = errors.New("invalid Proxmox guest status response")
+
+func readGuestStatus[T any](resp *http.Response, vmid int) (*T, error) {
+ body, readErr := readResponseBodyLimited(resp.Body)
+ closeErr := resp.Body.Close()
+ if readErr != nil || closeErr != nil {
+ return nil, errors.Join(readErr, closeErr)
+ }
+ if resp.StatusCode != http.StatusOK || !utf8.Valid(body) {
+ return nil, errInvalidGuestStatusResponse
+ }
+ envelope, valid := inventoryResponseObject(body, "data", "errors")
+ if !valid {
+ return nil, errInvalidGuestStatusResponse
+ }
+ if failure, exists := envelope["errors"]; exists && !bytes.Equal(bytes.TrimSpace(failure), []byte("null")) {
+ return nil, errInvalidGuestStatusResponse
+ }
+ fields := append([]string{"balloon", "balloon_min", "ballooninfo", "freemem", "meminfo"}, guestInventoryFields...)
+ status, valid := inventoryResponseObject(envelope["data"], fields...)
+ if !valid {
+ return nil, errInvalidGuestStatusResponse
+ }
+ var state string
+ if json.Unmarshal(status["status"], &state) != nil || strings.TrimSpace(state) == "" {
+ return nil, errInvalidGuestStatusResponse
+ }
+ // PVE may omit vmid in this endpoint. If present, it must identify the
+ // requested guest exactly; retain LXC's integer-string compatibility, but
+ // do not let FlexInt's general numeric truncation accept a different ID.
+ if raw, exists := status["vmid"]; exists {
+ var id int
+ if json.Unmarshal(raw, &id) != nil {
+ var text string
+ if json.Unmarshal(raw, &text) != nil {
+ return nil, errInvalidGuestStatusResponse
+ }
+ var err error
+ id, err = strconv.Atoi(text)
+ if err != nil {
+ return nil, errInvalidGuestStatusResponse
+ }
+ }
+ if id <= 0 || id != vmid {
+ return nil, errInvalidGuestStatusResponse
+ }
+ }
+ var value T
+ if json.Unmarshal(envelope["data"], &value) != nil {
+ return nil, errInvalidGuestStatusResponse
+ }
+ return &value, nil
+}
diff --git a/pkg/proxmox/guest_status_response_test.go b/pkg/proxmox/guest_status_response_test.go
new file mode 100644
index 0000000000..77612431d3
--- /dev/null
+++ b/pkg/proxmox/guest_status_response_test.go
@@ -0,0 +1,190 @@
+package proxmox
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "testing"
+ "time"
+)
+
+func testReadGuestStatus(c *Client, kind string) (string, time.Time, bool, error) {
+ if kind == "qemu" {
+ value, err := c.GetVMStatus(context.Background(), "member", 105)
+ if value == nil {
+ return "", time.Time{}, true, err
+ }
+ return value.Status, value.ObservedAt, false, err
+ }
+ value, err := c.GetContainerStatus(context.Background(), "member", 105)
+ if value == nil {
+ return "", time.Time{}, true, err
+ }
+ return value.Status, value.ObservedAt, false, err
+}
+
+// Real HTTP reads: no malformed success may become a fresh guest observation.
+func TestGuestStatusResponseAdmission(t *testing.T) {
+ const valid = `{"data":{"status":"running","uptime":12,"netin":10}}`
+ for _, kind := range []string{"qemu", "lxc"} {
+ for _, tc := range []struct {
+ name, body string
+ truncated bool
+ }{
+ {"missing-data", `{}`, false},
+ {"null-data", `{"data":null}`, false},
+ {"null-envelope", `null`, false},
+ {"array-data", `{"data":[]}`, false},
+ {"empty-data", `{"data":{}}`, false},
+ {"missing-state", `{"data":{"uptime":12}}`, false},
+ {"null-state", `{"data":{"status":null}}`, false},
+ {"empty-state", `{"data":{"status":" "}}`, false},
+ {"wrong-state-type", `{"data":{"status":true}}`, false},
+ {"case-data", `{"Data":{"status":"running"}}`, false},
+ {"duplicate-data", `{"data":{"status":"stopped"},"data":{"status":"running"}}`, false},
+ {"escaped-duplicate-data", `{"data":{"status":"stopped"},"\u0064ata":{"status":"running"}}`, false},
+ {"case-overwrite", `{"data":{"status":"stopped"},"Data":{"status":"running"}}`, false},
+ {"duplicate-state", `{"data":{"status":"stopped","status":"running"}}`, false},
+ {"escaped-duplicate-state", `{"data":{"status":"stopped","\u0073tatus":"running"}}`, false},
+ {"case-state", `{"data":{"status":"stopped","Status":"running"}}`, false},
+ {"case-lock", `{"data":{"status":"running","Lock":"backup"}}`, false},
+ {"duplicate-counter", `{"data":{"status":"running","netin":10,"netin":0}}`, false},
+ {"case-counter", `{"data":{"status":"running","Netin":10}}`, false},
+ {"case-memory", `{"data":{"status":"running","Meminfo":{"available":0}}}`, false},
+ {"conflicting-error", `{"data":{"status":"running"},"errors":{"message":"fixture-private-detail"}}`, false},
+ {"case-error", `{"data":{"status":"running"},"Errors":null}`, false},
+ {"trailing-value", valid + ` {"data":{"status":"stopped"}}`, false},
+ {"trailing-garbage", valid + `fixture-private-detail`, false},
+ {"truncated-after-prefix", valid, true},
+ {"oversized-after-prefix", valid + strings.Repeat(" ", int(maxResponseBodyBytes)), false},
+ {"invalid-utf8", `{"data":{"status":"running"},"metadata":"` + string([]byte{0xff}) + `"}`, false},
+ {"foreign-guest", `{"data":{"status":"running","vmid":106}}`, false},
+ {"null-guest", `{"data":{"status":"running","vmid":null}}`, false},
+ {"zero-guest", `{"data":{"status":"running","vmid":0}}`, false},
+ {"fractional-guest", `{"data":{"status":"running","vmid":105.5}}`, false},
+ {"fractional-string-guest", `{"data":{"status":"running","vmid":"105.5"}}`, false},
+ {"duplicate-guest", `{"data":{"status":"running","vmid":106,"vmid":105}}`, false},
+ {"invalid-value", `{"data":{"status":"running","uptime":"fixture-private-detail"}}`, false},
+ } {
+ t.Run(kind+"/"+tc.name, func(t *testing.T) {
+ var requests atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ requests.Add(1)
+ if r.URL.Path != "/api2/json/nodes/member/"+kind+"/105/status/current" {
+ t.Errorf("unexpected path: %s", r.URL.Path)
+ }
+ if tc.truncated {
+ w.Header().Set("Content-Length", fmt.Sprint(len(tc.body)+100))
+ }
+ fmt.Fprint(w, tc.body)
+ }))
+ defer server.Close()
+ _, at, nilResult, err := testReadGuestStatus(backupTestClient(t, server.URL), kind)
+ if err == nil || !nilResult || !at.IsZero() {
+ t.Errorf("unverified guest observation admitted: nil=%t time=%s err=%v", nilResult, at, err)
+ }
+ if err != nil && strings.Contains(err.Error(), "fixture-private-detail") {
+ t.Error("response material leaked into diagnostic")
+ }
+ if requests.Load() != 1 {
+ t.Errorf("invalid success replayed: %d", requests.Load())
+ }
+ })
+ }
+ }
+}
+
+func TestGuestStatusAcceptedCompatibility(t *testing.T) {
+ for _, kind := range []string{"qemu", "lxc"} {
+ for _, state := range []string{"running", "stopped", "paused", "future-provider-state"} {
+ for _, identity := range []string{"", `,"vmid":105`, `,"vmid":"105"`} {
+ t.Run(kind+"/"+state+identity, func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, `{"data":{"status":%q%s,"provider-metadata":{"revision":1}},"errors":null,"total":1}`, state, identity)
+ }))
+ defer server.Close()
+ before := time.Now()
+ got, at, nilResult, err := testReadGuestStatus(backupTestClient(t, server.URL), kind)
+ if err != nil || nilResult || got != state || at.Before(before) || at.After(time.Now()) {
+ t.Fatalf("compatible state refused or incorrectly timed: %q %s nil=%t err=%v", got, at, nilResult, err)
+ }
+ })
+ }
+ }
+ }
+ t.Run("qemu-metrics", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprint(w, `{"data":{"status":"running","cpu":0.25,"cpus":2,"mem":512,"maxmem":1024,"balloon":768,"balloon_min":256,"freemem":128,"meminfo":{"total":1024,"available":0},"ballooninfo":{"total_mem":1024,"free_mem":128},"disk":50,"maxdisk":100,"diskread":0,"diskwrite":null,"netin":32,"uptime":12,"agent":1,"lock":"backup"}}`)
+ }))
+ defer server.Close()
+ got, err := backupTestClient(t, server.URL).GetVMStatus(context.Background(), "member", 105)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got.CPU != .25 || got.CPUs != 2 || got.Mem != 512 || got.MaxMem != 1024 || got.Balloon != 768 || got.BalloonMin != 256 || got.FreeMem != 128 || got.MemInfo == nil || !got.MemInfo.AvailabilityKnown || got.MemInfo.Available != 0 || got.BalloonInfo == nil || got.BalloonInfo.TotalMem != 1024 || got.Disk != 50 || got.MaxDisk != 100 || got.NetIn != 32 || got.Uptime != 12 || !got.Agent.IsEnabled() || got.Lock != "backup" {
+ t.Fatalf("QEMU fields changed: %+v", got)
+ }
+ if got.IOCounters != (IOCounterPresence{Explicit: true, DiskRead: true, NetworkIn: true}) {
+ t.Fatalf("missing/null/zero counter semantics changed: %+v", got.IOCounters)
+ }
+ })
+ t.Run("lxc-metrics", func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprint(w, `{"data":{"status":"running","vmid":"105","cpus":"2","cpu":0.25,"mem":512,"maxmem":1024,"swap":0,"maxswap":256,"disk":50,"maxdisk":100,"diskread":0,"netout":32,"uptime":12,"ip":"192.0.2.5","network":{"eth0":{"name":"eth0","ip":"192.0.2.5/24"}},"diskinfo":{"rootfs":{"total":100,"used":50}}}}`)
+ }))
+ defer server.Close()
+ got, err := backupTestClient(t, server.URL).GetContainerStatus(context.Background(), "member", 105)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got.VMID != 105 || got.CPUs != 2 || got.CPU != .25 || got.Mem != 512 || got.MaxMem != 1024 || got.MaxSwap != 256 || got.Disk != 50 || got.MaxDisk != 100 || got.NetOut != 32 || got.Uptime != 12 || got.IP != "192.0.2.5" || len(got.Network) != 1 || got.DiskInfo["rootfs"].Used != 50 {
+ t.Fatalf("LXC fields changed: %+v", got)
+ }
+ if got.IOCounters != (IOCounterPresence{Explicit: true, DiskRead: true, NetworkOut: true}) {
+ t.Fatalf("missing/zero counter semantics changed: %+v", got.IOCounters)
+ }
+ })
+}
+
+type guestStatusCloseFailure struct {
+ io.Reader
+ closed bool
+}
+
+func (b *guestStatusCloseFailure) Close() error {
+ b.closed = true
+ return errors.New("fixture close failed")
+}
+
+func TestGuestStatusRequiresCompletedResponse(t *testing.T) {
+ for _, kind := range []string{"qemu", "lxc"} {
+ for _, code := range []int{http.StatusNoContent, http.StatusPartialContent} {
+ resp := &http.Response{StatusCode: code, Body: io.NopCloser(strings.NewReader(`{"data":{"status":"running"}}`))}
+ var err error
+ if kind == "qemu" {
+ _, err = readGuestStatus[VMStatus](resp, 105)
+ } else {
+ _, err = readGuestStatus[Container](resp, 105)
+ }
+ if err == nil {
+ t.Errorf("status %d established %s observation", code, kind)
+ }
+ }
+ body := &guestStatusCloseFailure{Reader: strings.NewReader(`{"data":{"status":"running"}}`)}
+ resp := &http.Response{StatusCode: http.StatusOK, Body: body}
+ var err error
+ if kind == "qemu" {
+ _, err = readGuestStatus[VMStatus](resp, 105)
+ } else {
+ _, err = readGuestStatus[Container](resp, 105)
+ }
+ if err == nil || !body.closed {
+ t.Errorf("close failure established %s observation: closed=%t err=%v", kind, body.closed, err)
+ }
+ }
+}