@synopackageland/cli 0.4.0 → 0.5.0

package/dist/templates/native-go/backend/internal/helper/observation_health_test.go

@@ -0,0 +1,127 @@
+package helper
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+	"time"
+)
+
+func TestReadinessPreservesAdmissionRefusal(t *testing.T) {
+	now := time.Now()
+	b := testBinding()
+	g := newAdmission(b)
+	g.observeUnit(b, 7, "", false, true, 0, now)
+	if g.readiness(now) != "ready" || !g.allow(now) {
+		t.Fatal("fresh readiness")
+	}
+	g.requestUnitCheck(true, now)
+	if g.readiness(now) != "reload-revalidating" || g.allow(now) {
+		t.Fatal("suspension must still refuse")
+	}
+	g.fence("unit-transition")
+	if g.readiness(now) != "fenced" || g.allow(now) {
+		t.Fatal("terminal refusal")
+	}
+}
+
+func TestPendingHealthBoundariesAndFencePrecedence(t *testing.T) {
+	now := time.Now()
+	b := testBinding()
+	fresh := func() *admission { g := newAdmission(b); g.observeUnit(b, 7, "", false, true, 0, now); return g }
+	t.Run("post-budget", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		g.requestUnitCheck(false, now.Add(9*time.Second))
+		if g.readiness(now.Add(11999*time.Millisecond)) != "reload-revalidating" || g.allow(now.Add(11999*time.Millisecond)) {
+			t.Fatal("post budget admission")
+		}
+		if g.readiness(now.Add(12*time.Second)) != "fenced" || g.observerDiagnostic("").Fence.Detail != "verification-deadline" {
+			t.Fatal("late health not fenced")
+		}
+		g.observeUnit(b, 7, "", false, true, g.unitSerial, now.Add(12*time.Second))
+		if g.readiness(now.Add(12*time.Second)) != "fenced" {
+			t.Fatal("sticky fence lost")
+		}
+	})
+	t.Run("reload-cap", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		if g.readiness(now.Add(9999*time.Millisecond)) != "reload-revalidating" {
+			t.Fatal("missing pending")
+		}
+		if g.readiness(now.Add(10*time.Second)) != "fenced" || g.observerDiagnostic("").Fence.Detail != "reload-deadline" {
+			t.Fatal("cap not enforced")
+		}
+	})
+	t.Run("unpaired-removal", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitRemoval(now)
+		if g.readiness(now) != "fenced" || g.allow(now) {
+			t.Fatal("pending without reload boundary")
+		}
+	})
+	t.Run("success", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		g.requestUnitCheck(false, now.Add(4*time.Second))
+		serial, _ := g.unitProbe(now.Add(4500 * time.Millisecond))
+		g.observeUnit(b, 7, "", false, true, serial, now.Add(4500*time.Millisecond))
+		if g.readiness(now.Add(4500*time.Millisecond)) != "ready" || !g.allow(now.Add(4500*time.Millisecond)) {
+			t.Fatal("fresh snapshot not ready")
+		}
+	})
+	for _, reason := range []string{"unit-transition", "installation-changed", "owner-changed", "observation-unavailable", "helper-exited", "grant-authority-fenced"} {
+		t.Run(reason, func(t *testing.T) {
+			g := fresh()
+			g.requestUnitCheck(true, now)
+			g.fence(reason)
+			if g.readiness(now) != "fenced" || g.reason() != reason || g.allow(now) {
+				t.Fatal("pending hid terminal fence")
+			}
+		})
+	}
+}
+
+func TestPendingReplyNeverCertifiesAdmissionOrStop(t *testing.T) {
+	i := fixture(t).Expected
+	for _, tc := range []struct {
+		res  Response
+		want string
+	}{
+		{Response{OK: true}, "ready"}, {Response{Error: "query-revalidating"}, "query-revalidating"}, {Response{OK: true, Error: "query-revalidating"}, "fenced"}, {Response{Error: "reload-revalidating"}, "reload-revalidating"},
+		{Response{OK: true, Error: "reload-revalidating"}, "fenced"}, {Response{Error: "fenced"}, "fenced"}, {Response{}, "fenced"},
+	} {
+		if got := supervisorReadiness(tc.res, nil); got != tc.want {
+			t.Fatalf("%+v -> %s", tc.res, got)
+		}
+	}
+	if supervisorReadiness(Response{Error: "reload-revalidating"}, errTrust) != "fenced" {
+		t.Fatal("untrusted refusal accepted")
+	}
+	res := Response{Inventory: i, Nonce: "nonce", Error: "reload-revalidating"}
+	data, _ := json.Marshal(res)
+	if readSupervisorReply(bytes.NewReader(data), i, "nonce") == nil {
+		t.Fatal("pending certified ACK")
+	}
+	for _, tc := range []struct {
+		data  []byte
+		nonce string
+	}{{data, "replay"}, {append(data, []byte("{}")...), "nonce"}, {[]byte(`{"inventory":{}}`), "nonce"}} {
+		if _, err := decodeSupervisorReply(bytes.NewReader(tc.data), i, tc.nonce); err == nil {
+			t.Fatal("unauthenticated reply accepted")
+		}
+	}
+}
+
+func TestQueryPendingReplyNeverCertifiesStop(t *testing.T) {
+	i := fixture(t).Expected
+	res := Response{Inventory: i, Nonce: "nonce", Error: "query-revalidating"}
+	data, _ := json.Marshal(res)
+	if readSupervisorReply(bytes.NewReader(data), i, "nonce") == nil {
+		t.Fatal("query pending certified ACK")
+	}
+	if supervisorReadiness(res, errTrust) != "fenced" {
+		t.Fatal("unauthenticated query pending")
+	}
+}

package/dist/templates/native-go/backend/internal/helper/observation_reload_budget_test.go

@@ -0,0 +1,117 @@
+package helper
+
+import (
+	"testing"
+	"time"
+)
+
+func TestReloadKeepsPostBoundaryVerificationBudget(t *testing.T) {
+	now := time.Now()
+	b := testBinding()
+	g := newAdmission(b)
+	g.observeUnit(b, 7, "", false, true, 0, now)
+	g.requestUnitCheck(true, now)
+	end := now.Add(2888 * time.Millisecond)
+	g.requestUnitCheck(false, end)
+	// 250ms watcher scheduling plus a 500ms query after a 2.888s reload.
+	serial, ready := g.unitProbe(end.Add(250 * time.Millisecond))
+	if !ready || g.fenced(end.Add(750*time.Millisecond)) {
+		t.Fatalf("reload consumed post budget: %s", g.reason())
+	}
+	g.observeUnit(b, 7, "", false, true, serial, end.Add(750*time.Millisecond))
+	if !g.allow(end.Add(750 * time.Millisecond)) {
+		t.Fatal("same v219 identity did not resume")
+	}
+}
+func TestReloadWindowsCannotBeExtended(t *testing.T) {
+	now := time.Now()
+	b := testBinding()
+	fresh := func() *admission { g := newAdmission(b); g.observeUnit(b, 7, "", false, true, 0, now); return g }
+	t.Run("fixed-reload", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		for n := 1; n < 10; n++ {
+			g.requestUnitCheck(true, now.Add(time.Duration(n)*time.Second))
+			g.requestUnitRemoval(now.Add(time.Duration(n) * time.Second))
+			if g.fenced(now.Add(time.Duration(n)*time.Second)) || g.allow(now) {
+				t.Fatal("premature fence or admission")
+			}
+		}
+		if !g.fenced(now.Add(10*time.Second)) || g.observerDiagnostic("").Fence.Detail != "reload-deadline" {
+			t.Fatal("reload cap extended")
+		}
+		g.requestUnitCheck(false, now.Add(10*time.Second))
+		if g.reason() == "" {
+			t.Fatal("late false erased fence")
+		}
+	})
+	t.Run("fixed-post", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		end := now.Add(4 * time.Second)
+		g.requestUnitCheck(false, end)
+		g.requestUnitCheck(false, end.Add(2*time.Second))
+		g.requestUnitRemoval(end.Add(2500 * time.Millisecond))
+		if !g.fenced(end.Add(3*time.Second)) || g.observerDiagnostic("").Fence.Detail != "verification-deadline" {
+			t.Fatal("duplicate false/removal extended post verification")
+		}
+	})
+	t.Run("no-reload", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitRemoval(now)
+		g.requestUnitCheck(false, now.Add(2*time.Second))
+		if !g.fenced(now.Add(3 * time.Second)) {
+			t.Fatal("unmatched false extended removal budget")
+		}
+	})
+	t.Run("chatter-total", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		g.requestUnitCheck(false, now.Add(9*time.Second))
+		g.requestUnitCheck(true, now.Add(9500*time.Millisecond))
+		g.requestUnitCheck(false, now.Add(9900*time.Millisecond))
+		if g.allow(now.Add(12900*time.Millisecond)) || !g.fenced(now.Add(13*time.Second)) {
+			t.Fatal("cycle bought extra budget")
+		}
+	})
+	t.Run("chatter-late-true", func(t *testing.T) {
+		g := fresh()
+		g.requestUnitCheck(true, now)
+		g.requestUnitCheck(false, now.Add(9*time.Second))
+		g.requestUnitCheck(true, now.Add(11*time.Second))
+		if !g.fenced(now.Add(11 * time.Second)) {
+			t.Fatal("new true bought a new cap")
+		}
+	})
+}
+
+func TestRemovalBeforeReloadStillHasAbsoluteCycleBound(t *testing.T) {
+	now := time.Now()
+	g := newAdmission(testBinding())
+	g.observeUnit(testBinding(), 7, "", false, true, 0, now)
+	g.requestUnitRemoval(now)
+	g.requestUnitCheck(true, now.Add(2900*time.Millisecond))
+	g.requestUnitCheck(false, now.Add(12*time.Second))
+	if !g.fenced(now.Add(13 * time.Second)) {
+		t.Fatal("early removal bought extra pending time")
+	}
+}
+
+func TestSuccessfulReloadStartsIndependentNextCycle(t *testing.T) {
+	now := time.Now()
+	b := testBinding()
+	g := newAdmission(b)
+	g.observeUnit(b, 7, "", false, true, 0, now)
+	for _, start := range []time.Time{now, now.Add(5 * time.Second)} {
+		g.requestUnitCheck(true, start)
+		g.requestUnitCheck(false, start.Add(4*time.Second))
+		serial, ready := g.unitProbe(start.Add(4500 * time.Millisecond))
+		if !ready {
+			t.Fatal("next cycle inherited expired cap")
+		}
+		g.observeUnit(b, 7, "", false, true, serial, start.Add(4500*time.Millisecond))
+		if !g.allow(start.Add(4500 * time.Millisecond)) {
+			t.Fatal("same identity rejected in fresh cycle")
+		}
+	}
+}

package/dist/templates/native-go/backend/internal/helper/observation_test.go

@@ -0,0 +1,196 @@
+package helper
+
+import (
+	"testing"
+	"time"
+)
+
+func TestObservationEdgesAreSticky(t *testing.T) {
+	g := newAdmission(testBinding())
+	now := time.Now()
+	g.observe(testBinding(), 7, true, now)
+	if !g.allow(now) {
+		t.Fatal("active refused")
+	}
+	g.observe(testBinding(), 7, true, now.Add(time.Millisecond))
+	if !g.allow(now) {
+		t.Fatal("same active update fenced")
+	}
+	g.fence("unit-stopped")
+	g.observe(testBinding(), 8, true, now.Add(time.Millisecond))
+	if g.allow(now) || g.reason() != "unit-stopped" {
+		t.Fatal("Stop/Start erased edge")
+	}
+}
+func TestObservationFreshnessAndInvocationRejectMissedTransitions(t *testing.T) {
+	for _, kind := range []string{"stale", "invocation", "install", "query"} {
+		t.Run(kind, func(t *testing.T) {
+			g := newAdmission(testBinding())
+			now := time.Now()
+			g.observe(testBinding(), 7, true, now)
+			switch kind {
+			case "stale":
+				now = now.Add(2 * time.Second)
+			case "invocation":
+				g.observe(testBinding(), 8, true, now)
+			case "install":
+				g.observe(Binding{Boot: "different", Install: testBinding().Install}, 7, true, now)
+			case "query":
+				g.observe(testBinding(), 7, false, now)
+			}
+			if g.allow(now) {
+				t.Fatal("untrusted observation admitted")
+			}
+		})
+	}
+}
+
+func TestReloadVerificationDeniesUntilFreshSnapshot(t *testing.T) {
+	b := testBinding()
+	g := newAdmission(b)
+	now := time.Now()
+	g.observe(b, 7, true, now)
+	g.requestUnitCheck(true, now)
+	if g.allow(now) || g.fenced(now) {
+		t.Fatal("reload must suspend, not permanently fence")
+	}
+	token, ready := g.unitProbe(now)
+	if ready {
+		t.Fatal("must wait for Reloading(false)")
+	}
+	g.requestUnitCheck(false, now.Add(time.Millisecond))
+	g.observeUnit(b, 7, "id", true, true, token, now.Add(2*time.Millisecond))
+	if g.allow(now) {
+		t.Fatal("pre-boundary snapshot cleared suspension")
+	}
+	token, ready = g.unitProbe(now)
+	if !ready {
+		t.Fatal("verification not scheduled")
+	}
+	g.observeUnit(b, 7, "id", true, true, token, now.Add(3*time.Millisecond))
+	if !g.allow(now.Add(3*time.Millisecond)) || g.binding.Entered != 7 {
+		t.Fatal("verified same epoch refused")
+	}
+}
+func TestReloadBudgetIsFixedAndFenceIsSticky(t *testing.T) {
+	b := testBinding()
+	g := newAdmission(b)
+	now := time.Now()
+	g.observe(b, 7, true, now)
+	g.requestUnitCheck(true, now)
+	for n := 1; n < 5; n++ {
+		g.requestUnitCheck(true, now.Add(time.Duration(n)*time.Second/2))
+	}
+	if !g.fenced(now.Add(unitReloadBudget)) || g.reason() != "observation-unavailable" {
+		t.Fatal("reload extended deadline")
+	}
+	g.requestUnitCheck(false, now.Add(unitReloadBudget))
+	token, _ := g.unitProbe(now)
+	g.observeUnit(b, 7, "", false, true, token, now.Add(unitReloadBudget))
+	if g.allow(now) {
+		t.Fatal("late snapshot erased timeout fence")
+	}
+}
+func TestReloadRejectsChangedIdentityAndStopEdges(t *testing.T) {
+	for _, kind := range []string{"timestamp", "invocation", "missing-invocation", "new-invocation", "inactive", "install", "boot", "stop", "query", "disconnect", "owner"} {
+		t.Run(kind, func(t *testing.T) {
+			b := testBinding()
+			g := newAdmission(b)
+			now := time.Now()
+			initialInv, initialPresent := "id", true
+			if kind == "new-invocation" {
+				initialInv, initialPresent = "", false
+			}
+			g.observeUnit(b, 7, initialInv, initialPresent, true, 0, now)
+			g.requestUnitCheck(true, now)
+			g.requestUnitCheck(false, now)
+			token, _ := g.unitProbe(now)
+			entered, inv, present, active := uint64(7), "id", true, true
+			switch kind {
+			case "timestamp":
+				entered = 8
+			case "invocation":
+				inv = "new"
+			case "missing-invocation":
+				present = false
+			case "new-invocation":
+				// The initial snapshot had no InvocationID property.
+			case "inactive":
+				active = false
+			case "install":
+				b.Install = "new"
+			case "boot":
+				b.Boot = "new"
+			case "stop":
+				g.fence("unit-stopped")
+			case "query", "disconnect":
+				g.fence("observation-unavailable")
+			case "owner":
+				g.fence("bus-owner-changed")
+			}
+			g.observeUnit(b, entered, inv, present, active, token, now)
+			g.observeUnit(testBinding(), 7, "id", true, true, token, now)
+			if g.allow(now) || !g.fenced(now) {
+				t.Fatal("transition erased by reload snapshot")
+			}
+		})
+	}
+}
+func TestRemovalWithoutReloadStillRequiresVerification(t *testing.T) {
+	b := testBinding()
+	g := newAdmission(b)
+	now := time.Now()
+	g.observeUnit(b, 7, "", false, true, 0, now)
+	g.requestUnitCheck(false, now)
+	if g.allow(now) || g.fenced(now) {
+		t.Fatal("unit removal directly admitted or fenced")
+	}
+	token, ready := g.unitProbe(now)
+	if !ready {
+		t.Fatal("missing bounded probe")
+	}
+	g.observeUnit(b, 7, "", false, true, token, now)
+	if !g.allow(now) {
+		t.Fatal("legacy systemd same active timestamp rejected")
+	}
+}
+
+func TestUnitProbeFailureRespectsReloadGenerationAndBudget(t *testing.T) {
+	for _, kind := range []string{"stale", "current", "owner", "install", "stop", "expired"} {
+		t.Run(kind, func(t *testing.T) {
+			now := time.Now()
+			g := newAdmission(testBinding())
+			g.observeUnit(testBinding(), 7, "id", true, true, 0, now)
+			old, _ := g.unitProbe(now)
+			g.requestUnitCheck(true, now)
+			g.requestUnitCheck(false, now)
+			reason, definitive := "observation-unavailable", false
+			switch kind {
+			case "current":
+				old, _ = g.unitProbe(now)
+			case "owner":
+				reason, definitive = "bus-owner-changed", true
+			case "install":
+				reason, definitive = "installation-changed", true
+			case "stop":
+				g.fence("unit-stopped")
+				reason = "unit-stopped"
+			case "expired":
+				now = now.Add(unitVerificationBudget)
+			}
+			blocked := g.failUnitProbe(old, reason, definitive, now)
+			if blocked != (kind != "stale") || g.allow(now) {
+				t.Fatalf("invalid outcome: blocked=%t reason=%s", blocked, g.reason())
+			}
+			serial, _ := g.unitProbe(now)
+			g.observeUnit(testBinding(), 7, "id", true, true, serial, now)
+			if kind == "stale" {
+				if !g.allow(now) {
+					t.Fatal("fresh query did not resume")
+				}
+			} else if g.allow(now) || g.reason() != reason {
+				t.Fatalf("sticky reason changed: %s", g.reason())
+			}
+		})
+	}
+}

package/dist/templates/native-go/backend/internal/helper/observer_diagnostic.go

@@ -0,0 +1,155 @@
+package helper
+
+import (
+	"encoding/json"
+	"strings"
+	"time"
+)
+
+const observerEventLimit = 64
+const observerDiagnosticLimit = 32768
+
+// Only fixed branch names and transport metadata belong here. Never store a
+// signal body, query value, installation identity, or an error's text.
+type observerEvent struct {
+	Stage          string    `json:"stage,omitempty"`
+	Code           Code      `json:"code,omitempty"`
+	At             time.Time `json:"at"`
+	Kind           string    `json:"kind"`
+	Detail         string    `json:"detail,omitempty"`
+	Phase          string    `json:"phase,omitempty"`
+	ErrorClass     string    `json:"errorClass,omitempty"`
+	Signal         string    `json:"signal,omitempty"`
+	Sender         string    `json:"sender,omitempty"`
+	WireSerial     uint32    `json:"wireSerial,omitempty"`
+	SignalSequence uint64    `json:"signalSequence,omitempty"`
+	QuerySerial    uint64    `json:"querySerial,omitempty"`
+}
+
+// One pinned period survives ring wrap. Timestamps contain no query values;
+// elapsed time is measured before UTC serialization, using Go's monotonic clock.
+type observerQueryPending struct {
+	StartedAt   time.Time `json:"startedAt"`
+	PendingAt   time.Time `json:"pendingAt"`
+	EndedAt     time.Time `json:"endedAt"`
+	Outcome     string    `json:"outcome"`
+	ElapsedNS   int64     `json:"elapsedNs"`
+	Phase       string    `json:"phase"`
+	ErrorClass  string    `json:"errorClass"`
+	QuerySerial uint64    `json:"querySerial"`
+}
+
+type observerDiagnostic struct {
+	QueryPending *observerQueryPending `json:"queryPending,omitempty"`
+	Schema       int                   `json:"schema"`
+	Epoch        string                `json:"epoch"`
+	Reason       string                `json:"reason"`
+	Fence        observerEvent         `json:"fence"`
+	Events       []observerEvent       `json:"events"`
+}
+
+func (g *admission) recordObserver(e observerEvent) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	g.recordObserverLocked(e)
+}
+func (g *admission) recordObserverLocked(e observerEvent) {
+	if e.At.IsZero() {
+		e.At = time.Now().UTC()
+	}
+	e.At = e.At.UTC()
+	g.events[g.eventNext] = e
+	g.eventNext = (g.eventNext + 1) % observerEventLimit
+	if g.eventCount < observerEventLimit {
+		g.eventCount++
+	}
+}
+func (g *admission) fenceObserver(reason string, e observerEvent) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	g.fenceObserverLocked(reason, e)
+}
+func (g *admission) fenceObserverLocked(reason string, e observerEvent) {
+	e.Kind = "fence"
+	if e.At.IsZero() {
+		e.At = time.Now()
+	}
+	if e.Detail == "" {
+		e.Detail = reason
+	}
+	if g.blocked == "" {
+		g.blocked = reason
+		g.firstFence = e
+		g.finishQueryPendingLocked("fence", e.At)
+		g.notifyObserverDiagnosticLocked()
+	}
+	g.recordObserverLocked(e)
+}
+func (g *admission) observerDiagnostic(epoch string) observerDiagnostic {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	d := observerDiagnostic{Schema: 1, Epoch: epoch, Reason: g.blocked, Fence: g.firstFence, Events: make([]observerEvent, g.eventCount)}
+	if g.queryPending != nil {
+		period := *g.queryPending
+		period.StartedAt = period.StartedAt.UTC()
+		period.PendingAt = period.PendingAt.UTC()
+		period.EndedAt = period.EndedAt.UTC()
+		d.QueryPending = &period
+	}
+	d.Fence.At = d.Fence.At.UTC()
+	start := (g.eventNext - g.eventCount + observerEventLimit) % observerEventLimit
+	for n := range d.Events {
+		d.Events[n] = g.events[(start+n)%observerEventLimit]
+	}
+	return d
+}
+
+// Coalesce notifications while storage is slow. The latest pinned period keeps
+// both endpoints even when a start and end arrive before the writer can run.
+func (g *admission) notifyObserverDiagnosticLocked() {
+	select {
+	case g.diagnosticWake <- struct{}{}:
+	default:
+	}
+}
+func (g *admission) finishQueryPendingLocked(outcome string, now time.Time) {
+	if g.queryPending == nil || g.queryPending.Outcome != "pending" {
+		return
+	}
+	g.queryPending.EndedAt = now
+	g.queryPending.Outcome = outcome
+	g.queryPending.ElapsedNS = int64(now.Sub(g.queryPending.StartedAt))
+	g.recordObserverLocked(observerEvent{At: now, Kind: "query-pending-ended", Detail: outcome, QuerySerial: g.unitSerial})
+	g.notifyObserverDiagnosticLocked()
+}
+
+// A write error cannot change a fence, admission, completion proof, or return
+// result. This fixed-size snapshot never stores signal bodies or query values.
+func persistObserverDiagnostic(c Client, epoch string, g *admission) {
+	d := g.observerDiagnostic(epoch)
+	if (d.Reason == "" && d.QueryPending == nil) || !digestPattern.MatchString(epoch) {
+		return
+	}
+	b, err := json.Marshal(d)
+	if err != nil || len(b) > observerDiagnosticLimit || protected(c.StateDir, c.Owner, true) != nil {
+		return
+	}
+	_ = writeProtected(c.StateDir, "observer-diagnostic.json", d)
+}
+func safeBusSender(s string) string {
+	if s == "org.freedesktop.DBus" {
+		return s
+	}
+	if len(s) < 4 || len(s) > 32 || s[0] != ':' {
+		return ""
+	}
+	for _, c := range s[1:] {
+		if (c < '0' || c > '9') && c != '.' {
+			return ""
+		}
+	}
+	if !strings.Contains(s, ".") {
+		return ""
+	}
+	return s
+}

package/dist/templates/native-go/backend/internal/helper/observer_diagnostic_linux.go

@@ -0,0 +1,76 @@
+package helper
+
+import (
+	"context"
+	"errors"
+	"github.com/godbus/dbus/v5"
+	"io"
+	"net"
+)
+
+func observerErrorClass(err error) string {
+	switch {
+	case errors.Is(err, context.Canceled):
+		return "canceled"
+	case errors.Is(err, context.DeadlineExceeded):
+		return "deadline"
+	case errors.Is(err, io.EOF):
+		return "eof"
+	case errors.Is(err, errTrust):
+		return "trust"
+	}
+	var timeout net.Error
+	if errors.As(err, &timeout) && timeout.Timeout() {
+		return "timeout"
+	}
+	var bus dbus.Error
+	if errors.As(err, &bus) {
+		switch bus.Name {
+		case "org.freedesktop.systemd1.NoSuchUnit":
+			return "dbus-no-unit"
+		case "org.freedesktop.DBus.Error.NoReply":
+			return "dbus-no-reply"
+		case "org.freedesktop.DBus.Error.Disconnected":
+			return "dbus-disconnected"
+		case "org.freedesktop.DBus.Error.NameHasNoOwner":
+			return "dbus-no-owner"
+		case "org.freedesktop.DBus.Error.ServiceUnknown":
+			return "dbus-service-unknown"
+		default:
+			return "dbus-other"
+		}
+	}
+	return "other"
+}
+func observerSignalName(name string) string {
+	switch name {
+	case "org.freedesktop.DBus.NameOwnerChanged", managerInterface + ".Reloading", managerInterface + ".UnitRemoved", managerInterface + ".JobNew", propertiesInterface + ".PropertiesChanged":
+		return name
+	}
+	return ""
+}
+
+// The godbus receive loop invokes this immediately before synchronous signal
+// delivery. Correlate header-only wire serial; Signal.Sequence is a different,
+// connection-local receive ordinal. Neither counter is an authority input.
+func (o *unitObserver) incomingObserverMessage(m *dbus.Message) {
+	if m.Type != dbus.TypeSignal {
+		return
+	}
+	iface, _ := m.Headers[dbus.FieldInterface].Value().(string)
+	member, _ := m.Headers[dbus.FieldMember].Value().(string)
+	sender, _ := m.Headers[dbus.FieldSender].Value().(string)
+	o.wireMu.Lock()
+	defer o.wireMu.Unlock()
+	o.wire = observerEvent{Signal: observerSignalName(iface + "." + member), Sender: safeBusSender(sender), WireSerial: m.Serial()}
+}
+func (o *unitObserver) signalEvent(s *dbus.Signal) observerEvent {
+	e := observerEvent{Kind: "signal", Signal: observerSignalName(s.Name), Sender: safeBusSender(s.Sender), SignalSequence: uint64(s.Sequence)}
+	o.wireMu.Lock()
+	defer o.wireMu.Unlock()
+	if e.Signal != "" && e.Signal == o.wire.Signal && e.Sender == o.wire.Sender {
+		e.WireSerial = o.wire.WireSerial
+	}
+	o.wire = observerEvent{}
+	return e
+}