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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Compare connected dashboard lifecycle with the exact parent delta oracle
pulse-triage[bot]9388cc2c7313
diff --git a/internal/websocket/connected_equivalence_test.go b/internal/websocket/connected_equivalence_test.gonew file mode 100644index 0000000000..0c40475e81--- /dev/null+++ b/internal/websocket/connected_equivalence_test.go@@ -0,0 +1,118 @@+package websocket++import (+ "encoding/json"+ "fmt"+ "reflect"+ "testing"++ "github.com/rcourtman/pulse-go-rewrite/internal/models"+)++func TestDashboardDispatchLifecycleEquivalence(t *testing.T) {+ state := benchmarkFrontendState(3)+ state.Resources[0].Labels = map[string]string{"team": "ops"}+ state.Resources[0].PlatformData = json.RawMessage(`{"counter":9007199254740993,"inventory":["a","b"]}`)+ state.Resources[0].Health = json.RawMessage(`{"status":"healthy","age":0}`)+ state.Resources[0].CapabilitiesRef = "cap"+ state.CapabilityCatalog = map[string]json.RawMessage{"cap": json.RawMessage(`{"read":true}`)}+ state.PolicyCatalog = map[string]json.RawMessage{"policy": json.RawMessage(`{"write":false}`)}+ state.AISafeSummaryCatalog = map[string]string{"summary": "initial"}+ state.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{{ID: "infra", LastSeen: 1, Status: "online"}}+ state.ActiveAlerts = []models.Alert{{ID: "alert", Level: "warning", Message: "initial"}}+ getter := func(string) interface{} { return state }+ hub := NewHub(getter)+ clients := []*Client{{orgID: "own", send: make(chan []byte, 1)}, {orgID: "own", send: make(chan []byte, 1)}, {orgID: "other", send: make(chan []byte, 1)}}+ for _, client := range clients {+ if _, sent, err := client.queueFullState("initialState", state); err != nil || !sent {+ t.Fatal(err)+ }+ <-client.send+ hub.clients[client] = true+ if hub.clientsByTenant[client.orgID] == nil {+ hub.clientsByTenant[client.orgID] = map[*Client]bool{}+ }+ hub.clientsByTenant[client.orgID][client] = true+ }+ otherBaseline := clients[2].stateSnapshot+ for phase := 0; phase < 8; phase++ {+ t.Run(fmt.Sprint(phase), func(t *testing.T) {+ before := clients[0].stateSnapshot+ switch phase {+ case 0:+ state.LastUpdate = 9007199254740993+ for i := range state.Resources {+ state.Resources[i].LastSeen = 9007199254740993+ }+ state.ConnectedInfrastructure[0].LastSeen = 9007199254740993+ case 1:+ state.Resources[0].CPU.Current = 32.25+ state.Resources[0].Network = &models.ResourceNetworkFrontend{RXBytes: 9007199254740993}+ state.Resources[0].PlatformData = json.RawMessage(`{"counter":18446744073709551615,"inventory":["c"]}`)+ case 2:+ state.Resources[0].Health = json.RawMessage(`{"status":"unhealthy","age":70}`)+ state.Resources[0].Alerts = []models.ResourceAlertFrontend{{ID: "live", Level: "critical"}}+ state.ActiveAlerts[0].Level = "critical"+ case 3:+ state.Resources[0].Labels = map[string]string{"team": "changed"}+ state.Resources[0].Tags = []string{"new"}+ state.Resources[0].CustomURL = "https://example.invalid/updated"+ state.Resources[0].ParentID = "changed-owner"+ state.Resources[0].DisplayName = "changed"+ state.Resources[0], state.Resources[1] = state.Resources[1], state.Resources[0]+ case 4:+ state.CapabilityCatalog["cap"] = json.RawMessage(`{"read":false}`)+ state.PolicyCatalog = nil+ state.AISafeSummaryCatalog["summary"] = "changed"+ state.ConnectionHealth = map[string]bool{"source": false}+ case 5:+ state.Resources = state.Resources[:1]+ state.Resources[0].ID = "re-enrolled-identity"+ state.ConnectedInfrastructure = nil+ state.ActiveAlerts = nil+ case 6:+ state.Resources[0].Health = nil+ state.Resources[0].Alerts = nil+ state.Resources[0].PlatformData = nil+ state.ConnectionHealth = nil+ case 7: // unchanged evidence must not manufacture a heartbeat+ }+ current, err := buildGenericClientStateSnapshot(state)+ if err != nil {+ t.Fatal(err)+ }+ want, err := referenceBuildClientStateDelta(before, current)+ if err != nil {+ t.Fatal(err)+ }+ encoded, err := json.Marshal(Message{Type: "rawData", Data: want})+ if err != nil {+ t.Fatal(err)+ }+ hub.dispatchStateBroadcast(&Message{Type: "rawData", Data: stateBroadcastRequest{orgID: "own"}}, "own")+ for _, client := range clients[:2] {+ select {+ case frame := <-client.send:+ if len(want) == 0 || !reflect.DeepEqual(decodeExactDeltaJSON(t, frame), decodeExactDeltaJSON(t, encoded)) {+ t.Fatalf("reference/wire mismatch: want=%s got=%s", encoded, frame)+ }+ default:+ if len(want) != 0 {+ t.Fatalf("missing live frame: want=%s", encoded)+ }+ }+ }+ if clients[0].stateSnapshot != clients[1].stateSnapshot {+ t.Fatal("accepted clients diverged baselines")+ }+ select {+ case frame := <-clients[2].send:+ t.Fatalf("cross-tenant data: %s", frame)+ default:+ }+ if clients[2].stateSnapshot != otherBaseline {+ t.Fatal("unrelated tenant baseline changed")+ }+ })+ }+}diff --git a/internal/websocket/merge_patch_reference_test.go b/internal/websocket/merge_patch_reference_test.goindex 4653be438b..10b8585109 100644--- a/internal/websocket/merge_patch_reference_test.go+++ b/internal/websocket/merge_patch_reference_test.go@@ -6,6 +6,7 @@ import ("fmt""io""reflect"+ "sort")// Exact d14a3891 pre-change implementation, independent of the new raw-object path.@@ -89,3 +90,108 @@ func referenceDiffJSONMergeValue(previous, current interface{}) (interface{}, bo}return patch, len(patch) > 0}++func referenceBuildKeyedArrayDelta(+ previousEntries, currentEntries map[string]json.RawMessage,+ previousOrder, currentOrder []string,+ label string,+) (resourceDeltaPayload, error) {+ payload := resourceDeltaPayload{}+ for _, id := range currentOrder {+ currentEntry := currentEntries[id]+ previousEntry, exists := previousEntries[id]+ if !exists {+ payload.Upserts = append(payload.Upserts, currentEntry)+ continue+ }+ if bytes.Equal(previousEntry, currentEntry) {+ continue+ }+ patch, err := referenceJSONMergePatch(previousEntry, currentEntry)+ if err != nil {+ return resourceDeltaPayload{}, fmt.Errorf("build %s %q patch: %w", label, id, err)+ }+ payload.Upserts = append(payload.Upserts, patch)+ }+ for id := range previousEntries {+ if _, exists := currentEntries[id]; !exists {+ payload.Removed = append(payload.Removed, id)+ }+ }+ sort.Strings(payload.Removed)+ if !reflect.DeepEqual(previousOrder, currentOrder) {+ payload.Order = append([]string(nil), currentOrder...)+ }+ return payload, nil+}++func referenceBuildClientStateDelta(previous, current *clientStateSnapshot) (map[string]interface{}, error) {+ if previous == nil || current == nil {+ return nil, fmt.Errorf("state delta requires previous and current snapshots")+ }++ delta := make(map[string]interface{})+ for key, currentValue := range current.fields {+ if previousValue, ok := previous.fields[key]; !ok || !bytes.Equal(previousValue, currentValue) {+ delta[key] = currentValue+ }+ }+ for key := range previous.fields {+ if _, ok := current.fields[key]; !ok {+ delta[key] = nil+ }+ }++ resourceDelta, err := referenceBuildKeyedArrayDelta(+ previous.resources,+ current.resources,+ previous.resourceOrder,+ current.resourceOrder,+ "resource",+ )+ if err != nil {+ return nil, err+ }+ if !resourceDelta.isEmpty() {+ delta[resourceDeltaField] = resourceDelta+ }++ for _, keyedField := range keyedDeltaFields {+ previousSnapshot := previous.keyed[keyedField.field]+ currentSnapshot := current.keyed[keyedField.field]+ switch {+ case previousSnapshot != nil && currentSnapshot != nil:+ keyedDelta, err := referenceBuildKeyedArrayDelta(+ previousSnapshot.entries,+ currentSnapshot.entries,+ previousSnapshot.order,+ currentSnapshot.order,+ keyedField.field,+ )+ if err != nil {+ return nil, err+ }+ if !keyedDelta.isEmpty() {+ delta[keyedField.deltaField] = keyedDelta+ }+ case currentSnapshot != nil:+ // The previous snapshot carried the array as a plain field (or+ // not at all): fall back to shipping the full array once so the+ // client re-adopts a clean baseline.+ if previousRaw, ok := previous.fields[keyedField.field]; !ok ||+ !bytes.Equal(previousRaw, currentSnapshot.raw) {+ delta[keyedField.field] = currentSnapshot.raw+ }+ case previousSnapshot != nil:+ // The array left the keyed path. If the current snapshot still+ // carries it as a plain field, the fields loop above already+ // shipped it whole; if it vanished entirely, clear it like any+ // removed field.+ if _, ok := current.fields[keyedField.field]; !ok {+ delta[keyedField.field] = nil+ }+ }+ }++ return delta, nil+}