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
Apply operator links in the mock-mode unified view
rcourtmancccb43ecdf79
diff --git a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md b/docs/release-control/v6/internal/subsystems/agent-lifecycle.mdindex 21997c6afe..c9a8520708 100644--- a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md+++ b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md@@ -8982,6 +8982,18 @@ their own heartbeat cutoff (`fleethealth.AgentStaleThreshold`, which isseparate from the monitoring reporting lease). Agent registration, enrolment,install, update, removal and report identity are unchanged.+### Mock-mode read views fold linked fixture agents++`internal/monitoring/monitor.go` changed only so the mock-mode unified view+applies the operator's manual links (unified-resources contract, "Mock-mode+unified view applies operator links"). A fixture agent the operator linked+into a guest now folds into that guest in mock read views, as a linked agent+already does in live mode, so host snapshots built from them+(`HostsSnapshot`) stop listing it while the guest carries its facet. Agent+registration, enrolment, report admission, removal, continuity and the+fixture agent set itself are unchanged, and the view writes nothing to the+resource store.+### Demo write guard ignores websocket upgrade headers`internal/api/demo_middleware.go` changed only so a `POST`, `PUT`, `PATCH` ordiff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.mdindex d213a427c3..8a28184bd9 100644--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@ -2834,6 +2834,38 @@ overlap/covered-write/liveness/resumption dependency. Preserve the monitoringand alert outage precaution until that operational outcome is verified.+### Mock-mode unified view applies operator links++The mock branch of `currentUnifiedStateView` builds the view the broadcast,+`/api/state`, `GetUnifiedReadStateOrSnapshot` and `UnifiedResourceSnapshot`+serve in mock mode from the fixture graph, which knows no link store. It now+builds the graph with the links the monitor's resource store applied at its+current generation (`resourceStoreManualLinks`,+`mock.UnifiedResourceSnapshotWithLinks`; unified-resources contract+"Mock-mode unified view applies operator links"), so a link reaches the mock+broadcast when the resource store's next rebuild loads it, as in live mode; in+mock mode that is normally the broadcast's own read-path refresh once the+generation is older than `readPathRegistryFreshness`. The cached view is keyed+on the fixture data version and the link list, so a link change rebuilds it+without a fixture tick; an unchanged list keeps the shared build. Freshness,+which the resources API keys its registry cache on, is assigned in+publication order under `mockUnifiedViewMu`: a view built from the same+fixture freshness and links as the one it replaces keeps its freshness, and+any other view gets a later one than every view before it, so a slow build+that publishes late cannot reuse a value. With no links the view still comes+from the shared memoized fixture snapshot, so the demo's allocation profile is+unchanged; with links each monitor builds its own linked snapshot whenever+the fixture data or links change (concurrent misses can each build one). The fence view behind `currentModeReadState` still omits links (see+the mock-mode fence above): it stays a plain projection of current state for+the window before a rebuild in the new epoch, after which the registry applies+the links again. `TestMockUnifiedViewAppliesOperatorManualLinks` in+`internal/monitoring/monitor_host_agents_test.go` pins the broadcast, the+freshness advance and the cache, `TestFixtureGraphAppliesManualLinksAtEachIngestStage`+and `TestUnifiedResourceSnapshotWithLinksLeavesTheSharedSnapshotUnlinked` in+`internal/mock/platform_fixtures_test.go` pin the linked fixture build, and+`TestMockUnifiedStateViewUsesCanonicalMockFixtureGraph` in+`internal/monitoring/canonical_guardrails_test.go` pins the call.+### Saved quiet-hours policy before queue activation`Monitor.New` binds `alerts.Manager.QuietHoursNotificationPolicy` to thediff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex 7ed66c3921..50d7194f43 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -6616,9 +6616,9 @@ snapshot and resource ingest applied links, the rebuilt registry behind thewebsocket broadcast and `/api/state` kept both rows. The resources API, whichseeds through resource ingest, showed them merged, and so did the publishedinventory whenever an unrelated absent machine made continuity hydration-clone the registry. Mock mode builds its unified view from fixtures without-the link store, so links do not reach the mock broadcast; that boundary is-separate.+clone the registry. Mock mode builds its unified view from fixtures and+applies the same links there ("Mock-mode unified view applies operator+links" below).- The monitor adapter passes its configured stale thresholds to recordingest, so a link joined there judges each side's metrics the way a@@ -6673,6 +6673,65 @@ thresholds on the rebuild, supplemental and overlay paths, andpublished inventory with no continuity, an unrelated absent machine and thelinked agent's own saved enrollment.+### Mock-mode unified view applies operator links++In mock mode the websocket broadcast, `/api/state`, and the monitor's+`GetUnifiedReadStateOrSnapshot` and `UnifiedResourceSnapshot` readers serve a+view of the fixture graph, not the monitor's resource store, and the fixture+graph was built without the link store. The resources API seeds its registry+from that same list through a registry backed by the link store, so a manual+link showed merged there while the broadcast kept both rows. The fixture graph+is now built with the links the monitor adapter's current registry generation+loaded from its store (`MonitorAdapter.ManualLinks`), in a registry that has+no store at all (`NewRegistryWithManualLinks`,+`mock.UnifiedResourceSnapshotWithLinks`). Nothing that build ingests can write+identity pins, canonical-ID successions or change records, and the view's read+state forwards no history to the operator's store, so fixture data stays out+of durable state through it.++- The links apply at each ingest stage, as in the live rebuild: the snapshot,+ then the TrueNAS and vSphere records, then availability. An availability+ check that names the folded resource by source reference resolves through+ the fold and projects onto the primary. Folding the finished list instead+ dropped the check with the folded row. A check that names the folded+ resource by canonical ID still loses its target, as live (fold history+ above).+- A link reaches the view when the adapter's next rebuild loads it, the same+ point at which the live broadcast picks it up. The view's cache is keyed on+ the fixture data version and on the links' resource pairs and primaries, so+ a link change rebuilds it without waiting for a fixture tick. Freshness is+ assigned in publication order: a view built from the same fixture+ freshness and links as the one it replaces keeps its freshness, and any+ other view gets a later one than every view published before it, even when+ a slower build publishes after a newer one. The resources API reuses its+ registry while that freshness is unchanged, so it follows the published+ view and does not keep a list other links folded, for example after a+ link's primary is reversed. Fixture freshness stands in for the fixture+ data, as it already did for that cache.+- Without links the view is built from the shared memoized fixture snapshot,+ as before. With links each monitor builds its own linked snapshot whenever+ the fixture data or links change (concurrent cache misses can each build+ one).+- Exclusions are not carried, as before. The broadcast's presentation+ coalescing does not consult exclusions in either mode, while the resources+ API's `ListForPresentation` does.+- An agent linked into a guest leaves the agent listings (`Hosts()` lists+ agent-type rows only) and the guest carries its facet, as in live mode.++`TestMockUnifiedViewAppliesOperatorManualLinks` in+`internal/monitoring/monitor_host_agents_test.go` pins the broadcast payload,+the rebuild and freshness advance on a link change with the fixture data+version held, the cached build afterwards, the same rows as a store-backed+registry seeded through resource ingest the way the resources API seeds, and+no change rows reaching the store through the view.+`TestFixtureGraphAppliesManualLinksAtEachIngestStage` and+`TestUnifiedResourceSnapshotWithLinksLeavesTheSharedSnapshotUnlinked` in+`internal/mock/platform_fixtures_test.go` pin the staged availability+projection and the untouched shared snapshot, and+`TestRegistryWithManualLinksFoldsLikeTheStoreBackedRegistry` in+`internal/unifiedresources/registry_test.go` pins the store-less registry+against the store-backed one and the per-generation `ManualLinks` snapshot.+### Provider link network corroborationAn existing reciprocal host/provider link remains authoritative, including adiff --git a/internal/mock/platform_fixtures.go b/internal/mock/platform_fixtures.goindex 19bb49cf2b..e479469b65 100644--- a/internal/mock/platform_fixtures.go+++ b/internal/mock/platform_fixtures.go@@ -189,8 +189,30 @@ func UnifiedResourceSnapshot() ([]unifiedresources.Resource, time.Time) {return resources, freshness}+// UnifiedResourceSnapshotWithLinks returns the current mock world as unified+// resources with the operator's manual links applied at each ingest stage, as+// the live monitor's registry rebuild applies them: a link whose side arrives+// as a supplemental record, or whose folded side an availability check names+// by source, folds as it would live. Folding the finished list instead loses+// both. The registry has no store, so nothing the fixtures ingest is+// persisted. Without links this is UnifiedResourceSnapshot; with links it+// builds afresh on every call, so callers cache it per fixture data version+// and link set, and its result is the caller's own.+func UnifiedResourceSnapshotWithLinks(links []unifiedresources.ResourceLink) ([]unifiedresources.Resource, time.Time) {+ if len(links) == 0 {+ return UnifiedResourceSnapshot()+ }+ if !IsMockEnabled() {+ return nil, time.Time{}+ }+ return CurrentFixtureGraph().unifiedResourceSnapshot(unifiedresources.NewRegistryWithManualLinks(links))+}+func (g FixtureGraph) UnifiedResourceSnapshot() ([]unifiedresources.Resource, time.Time) {- registry := unifiedresources.NewRegistry(nil)+ return g.unifiedResourceSnapshot(unifiedresources.NewRegistry(nil))+}++func (g FixtureGraph) unifiedResourceSnapshot(registry *unifiedresources.ResourceRegistry) ([]unifiedresources.Resource, time.Time) {registry.IngestSnapshot(unifiedresources.SnapshotWithoutSources(g.State, SupplementalOwnedSources()))for _, source := range SupplementalOwnedSources() {diff --git a/internal/mock/platform_fixtures_test.go b/internal/mock/platform_fixtures_test.goindex d7243b8704..7f25908432 100644--- a/internal/mock/platform_fixtures_test.go+++ b/internal/mock/platform_fixtures_test.go@@ -459,6 +459,103 @@ func TestFixtureGraphAttachesServiceAvailabilityFixturesToServiceResources(t *te}}+// TestFixtureGraphAppliesManualLinksAtEachIngestStage pins the linked build+// behind the mock-mode unified view. Folding the curated Docker service into a+// VM must move its availability check onto the VM, as the live rebuild's+// availability ingest resolves the check's source reference through the fold;+// folding the finished list dropped the facet with the folded row.+func TestFixtureGraphAppliesManualLinksAtEachIngestStage(t *testing.T) {+ now := time.Date(2026, time.May, 6, 12, 0, 0, 0, time.UTC)+ graph := buildFixtureGraph(DefaultConfig, now)+ unlinked, _ := graph.UnifiedResourceSnapshot()++ const checkID = "mock-availability-docker-frontend-service"+ var serviceID, vmID string+ for _, resource := range unlinked {+ switch {+ case resource.Type == unifiedresources.ResourceTypeDockerService && resource.Availability != nil &&+ resource.Availability.TargetID == checkID:+ serviceID = resource.ID+ case vmID == "" && resource.Type == unifiedresources.ResourceTypeVM && resource.Proxmox != nil:+ vmID = resource.ID+ }+ }+ if serviceID == "" || vmID == "" {+ t.Fatalf("fixture graph needs the checked Docker service and a Proxmox VM, got service=%q vm=%q", serviceID, vmID)+ }++ links := []unifiedresources.ResourceLink{{ResourceA: vmID, ResourceB: serviceID, PrimaryID: vmID}}+ linked, _ := graph.unifiedResourceSnapshot(unifiedresources.NewRegistryWithManualLinks(links))+ var vm, endpoint *unifiedresources.Resource+ for i := range linked {+ switch {+ case linked[i].ID == serviceID:+ t.Fatalf("linked build still lists the folded Docker service %s", serviceID)+ case linked[i].ID == vmID:+ vm = &linked[i]+ case linked[i].Type == unifiedresources.ResourceTypeNetworkEndpoint && linked[i].Availability != nil &&+ linked[i].Availability.TargetID == checkID:+ endpoint = &linked[i]+ }+ }+ if vm == nil || vm.Docker == nil {+ t.Fatalf("linked VM %s = %+v, want it to carry the folded service's Docker facet", vmID, vm)+ }+ if vm.Availability == nil || vm.Availability.TargetID != checkID {+ t.Fatalf("linked VM availability = %+v, want the folded service's check projected onto it", vm.Availability)+ }+ if !hasChecksEdgeTo(endpoint, vmID) {+ t.Fatalf("check relationships = %+v, want the checks edge to follow the fold to %s", endpoint, vmID)+ }+}++// TestUnifiedResourceSnapshotWithLinksLeavesTheSharedSnapshotUnlinked pins the+// memo boundary: a linked build belongs to its caller (one tenant's links),+// and the memoized snapshot every other reader shares stays unlinked.+func TestUnifiedResourceSnapshotWithLinksLeavesTheSharedSnapshotUnlinked(t *testing.T) {+ previous := IsMockEnabled()+ previousConfig := GetConfig()+ if previous {+ mustSetEnabled(t, false)+ }+ testConfig := previousConfig+ testConfig.UpdateInterval = 5 * time.Minute+ SetMockConfig(testConfig)+ mustSetEnabled(t, true)+ t.Cleanup(func() {+ mustSetEnabled(t, false)+ SetMockConfig(previousConfig)+ mustSetEnabled(t, previous)+ })++ shared, _ := UnifiedResourceSnapshot()+ if same, _ := UnifiedResourceSnapshotWithLinks(nil); len(same) == 0 || &same[0] != &shared[0] {+ t.Fatal("UnifiedResourceSnapshotWithLinks without links must serve the memoized snapshot")+ }+ var vmID, agentID string+ for _, resource := range shared {+ switch {+ case vmID == "" && resource.Type == unifiedresources.ResourceTypeVM && resource.Agent == nil:+ vmID = resource.ID+ case agentID == "" && resource.Type == unifiedresources.ResourceTypeAgent && resource.Agent != nil &&+ len(resource.Sources) == 1 && resource.Sources[0] == unifiedresources.SourceAgent:+ agentID = resource.ID+ }+ }+ if vmID == "" || agentID == "" {+ t.Fatalf("fixture graph needs an agentless VM and a standalone agent, got vm=%q agent=%q", vmID, agentID)+ }++ linked, _ := UnifiedResourceSnapshotWithLinks([]unifiedresources.ResourceLink{{ResourceA: vmID, ResourceB: agentID, PrimaryID: vmID}})+ if slices.ContainsFunc(linked, func(r unifiedresources.Resource) bool { return r.ID == agentID }) {+ t.Fatalf("linked build still lists the folded agent %s", agentID)+ }+ again, _ := UnifiedResourceSnapshot()+ if !slices.ContainsFunc(again, func(r unifiedresources.Resource) bool { return r.ID == agentID }) {+ t.Fatalf("the shared snapshot lost the agent %s after a linked build", agentID)+ }+}+// hasChecksEdgeTo reports whether the source-owned check row carries the// outgoing checks relationship to the resource it matched. The check row owns// that edge; the matched resource carries only the projected facet.diff --git a/internal/monitoring/canonical_guardrails_test.go b/internal/monitoring/canonical_guardrails_test.goindex e2110c7103..ec2a362b71 100644--- a/internal/monitoring/canonical_guardrails_test.go+++ b/internal/monitoring/canonical_guardrails_test.go@@ -2009,7 +2009,7 @@ func TestMockUnifiedStateViewUsesCanonicalMockFixtureGraph(t *testing.T) {requiredSnippets := []string{"version := mock.FixtureDataVersion()","m.mockUnifiedViewValid && m.mockUnifiedViewVersion == version",- "resources, freshness := mock.UnifiedResourceSnapshot()",+ "resources, freshness := mock.UnifiedResourceSnapshotWithLinks(links)","view := monitorUnifiedStateViewFromResources(resources, freshness)","m.mockUnifiedView = view","m.mockUnifiedViewVersion = version",diff --git a/internal/monitoring/monitor.go b/internal/monitoring/monitor.goindex 73f19993f8..0df72d1de8 100644--- a/internal/monitoring/monitor.go+++ b/internal/monitoring/monitor.go@@ -1216,6 +1216,8 @@ type Monitor struct {mockUnifiedViewMu sync.MutexmockUnifiedView monitorUnifiedStateViewmockUnifiedViewVersion uint64+ mockUnifiedViewLinks []unifiedresources.ResourceLink+ mockUnifiedViewFixtureAt time.Time // fixture freshness the published view was built frommockUnifiedViewValid boolpveClients map[string]PVEClientInterfacepbsClients map[string]*pbs.Client@@ -5146,27 +5148,55 @@ func (m *Monitor) currentUnifiedStateView() monitorUnifiedStateView {}if mock.IsMockEnabled() {- // Read the version before the snapshot so a tick landing in between- // caches newer data under an older token (harmless rebuild next- // call) rather than ever serving stale data under a newer one.+ // Read the version and links before the snapshot so a tick or+ // rebuild landing in between caches newer data under an older+ // token (harmless rebuild next call) rather than ever serving stale+ // data under a newer one.version := mock.FixtureDataVersion()+ links := m.resourceStoreManualLinks()m.mockUnifiedViewMu.Lock()- if m.mockUnifiedViewValid && m.mockUnifiedViewVersion == version {+ if m.mockUnifiedViewValid && m.mockUnifiedViewVersion == version && sameManualLinks(m.mockUnifiedViewLinks, links) {view := m.mockUnifiedViewm.mockUnifiedViewMu.Unlock()return view}m.mockUnifiedViewMu.Unlock()- resources, freshness := mock.UnifiedResourceSnapshot()+ // The fixture graph knows no link store, so the operator's links,+ // as the resource store's current generation applied them, are+ // applied while it is built, at each ingest stage like the live+ // rebuild. Its registry has no store: fixture data never reaches+ // durable state through it.+ resources, freshness := mock.UnifiedResourceSnapshotWithLinks(links)if len(resources) > 0 || !freshness.IsZero() {// Consumers share this view between ticks, mirroring the// sharing semantics the persistent-store ReadState path has// always had in real mode: views are read-only.view := monitorUnifiedStateViewFromResources(resources, freshness)m.mockUnifiedViewMu.Lock()+ // Readers key caches on freshness: the resources API reuses+ // its registry, seeded from this list, while freshness is+ // equal. A link change alters the view without moving any+ // fixture timestamp, and a slow build can publish after a+ // newer one, so freshness is assigned here, in publication+ // order: a view built from the fixture freshness and links of+ // the one it replaces keeps its freshness, and any other view+ // gets one later than every view published before it. Fixture+ // freshness stands in for the fixture data here, as it already+ // does for that cache.+ fixtureFreshness := view.freshness+ if m.mockUnifiedViewValid {+ previous := m.mockUnifiedView.freshness+ if fixtureFreshness.Equal(m.mockUnifiedViewFixtureAt) && sameManualLinks(m.mockUnifiedViewLinks, links) {+ view.freshness = previous+ } else if !view.freshness.After(previous) {+ view.freshness = previous.Add(time.Nanosecond)+ }+ }m.mockUnifiedView = view+ m.mockUnifiedViewFixtureAt = fixtureFreshnessm.mockUnifiedViewVersion = version+ m.mockUnifiedViewLinks = linksm.mockUnifiedViewValid = truem.mockUnifiedViewMu.Unlock()return view@@ -5202,6 +5232,33 @@ func (m *Monitor) currentUnifiedStateView() monitorUnifiedStateView {return m.unifiedStateViewWithStandaloneHostContinuity(monitorUnifiedStateViewFromSnapshot(m.GetState()))}+// manualLinkResourceStore is implemented by resource stores that apply the+// operator's manual links (MonitorAdapter).+type manualLinkResourceStore interface {+ ManualLinks() []unifiedresources.ResourceLink+}++// resourceStoreManualLinks returns the operator links the resource store's+// current generation applied, or nil when the store applies none.+func (m *Monitor) resourceStoreManualLinks() []unifiedresources.ResourceLink {+ m.mu.RLock()+ store := m.resourceStore+ m.mu.RUnlock()+ linkStore, ok := store.(manualLinkResourceStore)+ if !ok {+ return nil+ }+ return linkStore.ManualLinks()+}++// sameManualLinks reports whether two link lists fold the same resources in+// the same order. Link metadata (reason, author, time) does not change a fold.+func sameManualLinks(a, b []unifiedresources.ResourceLink) bool {+ return slices.EqualFunc(a, b, func(x, y unifiedresources.ResourceLink) bool {+ return x.ResourceA == y.ResourceA && x.ResourceB == y.ResourceB && x.PrimaryID == y.PrimaryID+ })+}+func (m *Monitor) currentUnifiedResourceFreshness() time.Time {if m == nil {return time.Time{}@@ -5286,7 +5343,11 @@ func (m *Monitor) GetUnifiedReadStateOrSnapshot() unifiedresources.ReadState {// the new epoch replaces it, so they get a view of current state meanwhile.// The view lists the state snapshot without provider-owned supplemental// resources or persisted manual links and copies the whole estate, so it is-// only for callers outside per-resource loops.+// only for callers outside per-resource loops. The links stay out because the+// view is a plain projection of current state for a short window: the links+// still apply in the registry once a rebuild in the new epoch lands. Meanwhile+// typed lookups see linked resources unmerged; the previous-state carry, for+// one, loses a manually linked agent's memory.func (m *Monitor) currentModeReadState() unifiedresources.ReadState {if m == nil {return nildiff --git a/internal/monitoring/monitor_host_agents_test.go b/internal/monitoring/monitor_host_agents_test.goindex f5abd19370..33946c6d9b 100644--- a/internal/monitoring/monitor_host_agents_test.go+++ b/internal/monitoring/monitor_host_agents_test.go@@ -7,6 +7,7 @@ import ("fmt""net""os"+ "slices""strings""sync/atomic""testing"@@ -5718,6 +5719,137 @@ func TestMockModeDropsRealHostContinuity(t *testing.T) {}}+// TestMockUnifiedViewAppliesOperatorManualLinks pins operator links on the+// mock-mode unified view. The fixture graph is built without the link store,+// so a standalone agent linked into a VM showed merged in the resources API,+// which re-seeds through the store-backed registry, but stayed a separate row+// in the websocket broadcast and /api/state. The view applies the links the+// monitor's resource store last loaded, rebuilds when they change without+// waiting for a fixture tick, and never forwards fixture data to the store.+func TestMockUnifiedViewAppliesOperatorManualLinks(t *testing.T) {+ previous := mock.IsMockEnabled()+ previousConfig := mock.GetConfig()+ if previous {+ mustSetMockEnabled(t, false)+ }+ // Hold the fixture graph still, so only the link can change the view.+ testConfig := previousConfig+ testConfig.UpdateInterval = 5 * time.Minute+ mock.SetMockConfig(testConfig)+ mustSetMockEnabled(t, true)+ t.Cleanup(func() {+ mustSetMockEnabled(t, false)+ mock.SetMockConfig(previousConfig)+ mustSetMockEnabled(t, previous)+ })++ store := unifiedresources.NewMemoryStore()+ m := &Monitor{+ state: models.NewState(),+ resourceStore: unifiedresources.NewMonitorAdapter(unifiedresources.NewRegistry(store)),+ alertManager: alerts.NewManager(),+ }+ t.Cleanup(m.alertManager.Stop)++ unlinked := m.currentUnifiedStateView()+ var vmID, agentID string+ for _, resource := range unlinked.resources {+ switch {+ case vmID == "" && resource.Type == unifiedresources.ResourceTypeVM && resource.Agent == nil:+ vmID = resource.ID+ case agentID == "" && resource.Type == unifiedresources.ResourceTypeAgent && resource.Agent != nil &&+ len(resource.Sources) == 1 && resource.Sources[0] == unifiedresources.SourceAgent:+ agentID = resource.ID+ }+ }+ if vmID == "" || agentID == "" {+ t.Fatalf("fixture graph needs an agentless VM and a standalone agent, got vm=%q agent=%q", vmID, agentID)+ }+ if err := store.AddLink(unifiedresources.ResourceLink{ResourceA: vmID, ResourceB: agentID, PrimaryID: vmID}); err != nil {+ t.Fatalf("AddLink: %v", err)+ }+ version := mock.FixtureDataVersion()++ // The broadcast's read-path refresh rebuilds the resource store, which+ // loads the link; the mock view must follow it within the same build.+ frontend := m.BuildBroadcastFrontendState()+ if got := mock.FixtureDataVersion(); got != version {+ t.Fatalf("fixture data version moved from %d to %d; the link alone must refresh the view", version, got)+ }+ var vmRow *models.ResourceFrontend+ for i := range frontend.Resources {+ switch frontend.Resources[i].ID {+ case vmID:+ vmRow = &frontend.Resources[i]+ case agentID:+ t.Fatalf("broadcast still lists the linked agent %s as its own row", agentID)+ }+ }+ if vmRow == nil || len(vmRow.Agent) == 0 {+ t.Fatalf("broadcast VM row %s = %+v, want it to carry the linked agent's facet", vmID, vmRow)+ }++ linked := m.currentUnifiedStateView()+ if linked.readState == unlinked.readState {+ t.Fatal("expected the view to rebuild when the operator links changed")+ }+ // The resources API keys its registry cache on this freshness, so a+ // link change must advance it even though no fixture tick did.+ if !linked.freshness.After(unlinked.freshness) {+ t.Fatalf("view freshness %v did not advance past %v on the link change", linked.freshness, unlinked.freshness)+ }+ if again := m.currentUnifiedStateView(); again.readState != linked.readState {+ t.Fatal("expected the linked view to stay cached while neither the fixtures nor the links change")+ }++ // The resources API re-seeds the same snapshot through a registry backed+ // by the link store. Both payloads must list the same rows.+ seed, _ := m.UnifiedResourceSnapshot()+ rest := unifiedresources.NewRegistry(store)+ rest.IngestResources(seed)+ viewIDs := make([]string, 0, len(linked.resources))+ for _, resource := range linked.resources {+ viewIDs = append(viewIDs, resource.ID)+ }+ restIDs := make([]string, 0, len(seed))+ for _, resource := range rest.List() {+ restIDs = append(restIDs, resource.ID)+ }+ slices.Sort(viewIDs)+ slices.Sort(restIDs)+ if !slices.Equal(viewIDs, restIDs) {+ t.Fatalf("mock view and resources API disagree:\nview %v\nrest %v", viewIDs, restIDs)+ }++ // The view's registry has no store: history recorded through the read+ // state it hands out must not land fixture rows in the operator's store.+ recorder, ok := linked.readState.(interface {+ RecordChange(unifiedresources.ResourceChange) error+ })+ if !ok {+ t.Fatalf("mock view read state %T does not record changes", linked.readState)+ }+ before, err := store.GetRecentChanges(vmID, time.Time{}, 1000)+ if err != nil {+ t.Fatalf("GetRecentChanges: %v", err)+ }+ if err := recorder.RecordChange(unifiedresources.ResourceChange{+ ID: "mock-view-probe",+ ObservedAt: time.Now().UTC(),+ ResourceID: vmID,+ Kind: unifiedresources.ChangeStateTransition,+ }); err != nil {+ t.Fatalf("RecordChange: %v", err)+ }+ after, err := store.GetRecentChanges(vmID, time.Time{}, 1000)+ if err != nil {+ t.Fatalf("GetRecentChanges: %v", err)+ }+ if len(after) != len(before) {+ t.Fatalf("mock view wrote %d change rows into the durable store", len(after)-len(before))+ }+}+// TestMockModeDiscardsRealHostReports pins the push-side of the mock clean// room. Mock mode already suspends pull-based PVE/PBS/PMG collection, but a// real agent keeps POSTing regardless; ingesting those reports lands a realdiff --git a/internal/unifiedresources/manual_links.go b/internal/unifiedresources/manual_links.gonew file mode 100644index 0000000000..0d4de9097c--- /dev/null+++ b/internal/unifiedresources/manual_links.go@@ -0,0 +1,30 @@+package unifiedresources++import "slices"++// NewRegistryWithManualLinks creates a registry that applies the given+// operator links on every ingest but has no store behind it. Read views built+// from data that never passed through the durable registry, such as the mock+// fixture graph, use it to show the operator's links the way the store-backed+// registry does, while nothing they ingest can persist identity pins,+// canonical-ID successions or change records. It carries no exclusions, so+// its identity matching and ListForPresentation see none.+func NewRegistryWithManualLinks(links []ResourceLink) *ResourceRegistry {+ rr := NewRegistry(nil)+ rr.links = slices.Clone(links)+ return rr+}++// ManualLinks returns the operator's manual links that the adapter's current+// registry generation applied, as loaded from its store when that generation+// was built. A link added to the store since then appears after the next+// rebuild, which is when the adapter's own listing folds it too.+func (a *MonitorAdapter) ManualLinks() []ResourceLink {+ registry := a.currentRegistry()+ if registry == nil {+ return nil+ }+ registry.mu.RLock()+ defer registry.mu.RUnlock()+ return slices.Clone(registry.links)+}diff --git a/internal/unifiedresources/registry_test.go b/internal/unifiedresources/registry_test.goindex 271c2c4a36..80df119e67 100644--- a/internal/unifiedresources/registry_test.go+++ b/internal/unifiedresources/registry_test.go@@ -2238,6 +2238,69 @@ func TestResourceRegistry_ManualNodeMergeRewritesProxmoxGuestParentAndActionAgen}}+// TestRegistryWithManualLinksFoldsLikeTheStoreBackedRegistry pins the+// store-less registry the mock-mode unified view seeds: given the links an+// adapter generation loaded, it folds already-unified resources exactly as a+// registry backed by the link store does. The adapter reports the links of its+// current generation and picks up a new one on its next rebuild.+func TestRegistryWithManualLinksFoldsLikeTheStoreBackedRegistry(t *testing.T) {+ now := time.Date(2026, 10, 7, 12, 0, 0, 0, time.UTC)+ resources := []Resource{+ {+ ID: "vm-checkout",+ Type: ResourceTypeVM,+ Name: "checkout-web-01",+ Status: StatusOnline,+ LastSeen: now,+ Sources: []DataSource{SourceProxmox},+ Proxmox: &ProxmoxData{SourceID: "pve:node1:101", NodeName: "node1", Instance: "pve", VMID: 101},+ },+ {+ ID: "agent-apollo",+ Type: ResourceTypeAgent,+ Name: "apollo-114",+ Status: StatusOnline,+ LastSeen: now,+ Sources: []DataSource{SourceAgent},+ Agent: &AgentData{AgentID: "agent-apollo", Hostname: "apollo-114"},+ },+ }+ link := ResourceLink{ResourceA: "vm-checkout", ResourceB: "agent-apollo", PrimaryID: "vm-checkout"}++ store := NewMemoryStore()+ adapter := NewMonitorAdapter(NewRegistry(store))+ if err := store.AddLink(link); err != nil {+ t.Fatalf("AddLink: %v", err)+ }+ if got := adapter.ManualLinks(); len(got) != 0 {+ t.Fatalf("ManualLinks before a rebuild = %+v, want the generation's empty set", got)+ }+ adapter.PopulateFromSnapshot(models.StateSnapshot{})+ links := adapter.ManualLinks()+ if len(links) != 1 || links[0].ResourceA != link.ResourceA || links[0].ResourceB != link.ResourceB || links[0].PrimaryID != link.PrimaryID {+ t.Fatalf("ManualLinks after a rebuild = %+v, want %+v", links, link)+ }+ links[0].PrimaryID = "agent-apollo"+ if got := adapter.ManualLinks(); got[0].PrimaryID != "vm-checkout" {+ t.Fatalf("ManualLinks handed out the registry's own slice: %+v", got)+ }+ links[0].PrimaryID = "vm-checkout"++ storeBacked := NewRegistry(store)+ storeBacked.IngestResources(resources)+ storeLess := NewRegistryWithManualLinks(links)+ // The registry keeps its own copy of the caller's links.+ links[0].ResourceB = "agent-other"+ storeLess.IngestResources(resources)++ for name, rr := range map[string]*ResourceRegistry{"store-backed": storeBacked, "store-less": storeLess} {+ got := rr.List()+ if len(got) != 1 || got[0].ID != "vm-checkout" || got[0].Agent == nil || got[0].Proxmox == nil {+ t.Fatalf("%s registry listed %v, want the VM carrying the linked agent", name, resourceIDs(got))+ }+ }+}+func TestResourceRegistry_ProxmoxGuestParentPrefersAgentBackedNodeDuplicate(t *testing.T) {rr := NewRegistry(nil)now := time.Date(2026, 5, 14, 10, 0, 0, 0, time.UTC)