@synopackageland/cli 0.5.0 → 0.6.0

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

@@ -1,127 +0,0 @@
-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/templates/native-go/backend/internal/helper/observation_reload_budget_test.go

@@ -1,117 +0,0 @@
-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/templates/native-go/backend/internal/helper/observation_test.go

@@ -1,196 +0,0 @@
-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/templates/native-go/backend/internal/helper/observer_diagnostic.go

@@ -1,155 +0,0 @@
-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/templates/native-go/backend/internal/helper/observer_diagnostic_linux.go

@@ -1,76 +0,0 @@
-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
-}