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.

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.go
new file mode 100644
index 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.go
index 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
+}