diff --git a/go/views/held_writer.go b/go/views/held_writer.go index c7957ac3..e6478fb9 100644 --- a/go/views/held_writer.go +++ b/go/views/held_writer.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "sort" + "strings" "sync" ) @@ -140,24 +141,34 @@ func (h *HeldWriter[F, C, S, A]) Held() []F { } // Start seeds what the writer holds from the keys of its state `findings` of the kinds it owns (design 47 G A-40, §580, H -// H-A-242: another bundle's keys are its own to state), what was written before it standing over them, writes what was -// written and clears what was cleared before it, and starts the writer. A part makes the writer before its module serves, -// so nothing is read from the state until now. +// H-A-242: another bundle's keys are its own to state, and are not read), what was written before it standing over them; +// writes what was written and clears what was cleared before it; clears once the keys of its retired kinds, never seeding +// them (H-A-247 (3)); and starts the writer. A part makes the writer before its module serves, so nothing is read from the +// state until now. func (h *HeldWriter[F, C, S, A]) Start(ctx context.Context) error { keys, err := h.state.Keys() if err != nil { return err } + var retired [][4]string h.mu.Lock() for _, k := range keys { + if h.Writer.retiredKey(k) { + // a kind no code raises any more: cleared once, never seeded (H-A-247 (3)) + scope, rest, _ := strings.Cut(k, ".") + if i := strings.LastIndex(rest, "."); i > 0 { + retired = append(retired, [4]string{scope, rest[:i], rest[i+1:], "the kind is retired: no code raises it any more"}) + } + continue + } + if !h.Writer.ownsKey(k) { + continue // another bundle's kind: it states its own (design 47 G §580, H H-A-242 (1)), and is not read + } e, err := h.state.Get(k) if err != nil { h.mu.Unlock() return err } - if !h.Writer.ownsKey(k) { - continue // another bundle's kind: it states its own (design 47 G §580, H H-A-242 (1)) - } if _, ok := h.held[k]; ok { continue } @@ -185,5 +196,10 @@ func (h *HeldWriter[F, C, S, A]) Start(ctx context.Context) error { return err } } + for _, c := range retired { + if err := h.Writer.clear(ctx, c[0], c[1], c[2], c[3]); err != nil { + return err + } + } return h.Writer.Start(ctx) } diff --git a/go/views/writer.go b/go/views/writer.go index 409afd32..6a8d680f 100644 --- a/go/views/writer.go +++ b/go/views/writer.go @@ -168,6 +168,10 @@ type WriterConfig[F, C, S, A any] struct { // naming it, its statement carries them as `kinds` and deletes only keys of them. None given, it owns every kind. // The kinds of a views reader (ViewKinds) are the reader's own and are always the writer's besides. Kinds []string + // Retired are kinds no code of the part raises any more, last owned by this writer (design 47 H H-A-247 (3)): a held + // writer's Start clears their keys, saying finding-cleared so the keeper clears their conditions, and never seeds them; + // a Write of one is refused as of any kind not owned. + Retired []string // JS is the bus connection's JetStream; Conn, when given, lets the writer hear the connection made again. JS jetstream.JetStream Conn *nats.Conn @@ -480,6 +484,12 @@ func (w *Writer[F, C, S, A]) statedKinds() []string { } // ownsKey says whether key is one of a kind the writer owns: its last part is the kind (`..`). +// retiredKey says whether key is of a kind in the writer's retired list (H-A-247 (3)). +func (w *Writer[F, C, S, A]) retiredKey(key string) bool { + i := strings.LastIndex(key, ".") + return i >= 0 && slices.Contains(w.cfg.Retired, key[i+1:]) +} + func (w *Writer[F, C, S, A]) ownsKey(key string) bool { if len(w.cfg.Kinds) == 0 { return true @@ -618,10 +628,15 @@ func (w *Writer[F, C, S, A]) Write(ctx context.Context, finding F) error { // Clear deletes the finding's key and says `finding-cleared`; a key that does not exist is deleted of nothing and is said // all the same, so a keeper holding the finding clears it (design 47 G §485). func (w *Writer[F, C, S, A]) Clear(ctx context.Context, scope, id, kind, why string) error { - key := FindingKey(scope, id, kind) if !w.owns(kind) { return w.refuse(kind) } + return w.clear(ctx, scope, id, kind, why) +} + +// clear is Clear of a kind the writer may clear: its own, or a retired one at a held writer's start (H-A-247 (3)). +func (w *Writer[F, C, S, A]) clear(ctx context.Context, scope, id, kind, why string) error { + key := FindingKey(scope, id, kind) w.mu.Lock() if err := w.cfg.State.Delete(key); err != nil { w.mu.Unlock() diff --git a/go/views/writer_test.go b/go/views/writer_test.go index 5ea263e4..148d780a 100644 --- a/go/views/writer_test.go +++ b/go/views/writer_test.go @@ -17,6 +17,26 @@ import ( "git.novox.be/novox/mesh-sdk/go/views" ) +// readState is a fakeState that names the keys read (H-A-247 (3): a held writer reads only its own keys). +type readState struct { + *fakeState + rmu sync.Mutex + got []string +} + +func (s *readState) Get(key string) (*stdio.StateEntry, error) { + s.rmu.Lock() + s.got = append(s.got, key) + s.rmu.Unlock() + return s.fakeState.Get(key) +} + +func (s *readState) read() []string { + s.rmu.Lock() + defer s.rmu.Unlock() + return slices.Clone(s.got) +} + // fakeState is an observer's state `findings` in memory. type fakeState struct { mu sync.Mutex @@ -656,9 +676,15 @@ func subHeldWriterSeedsAtStart(t *testing.T) { other.Kind = "b" rawOther, _ := json.Marshal(other) owned.m["module.other.b"] = rawOther + // H-A-247 (3): a retired kind's key is cleared once at Start, said as cleared, never seeded; no other bundle's key is read + gone := finding("gone", "no code raises it") + gone.Kind = "r" + rawGone, _ := json.Marshal(gone) + owned.m["module.gone.r"] = rawGone + read := &readState{fakeState: owned} var logs []string var sent []said - ocfg := testConfig{Module: "m", State: owned, Node: "n1", Asked: asked, Kinds: []string{"k"}, + ocfg := testConfig{Module: "m", State: read, Node: "n1", Asked: asked, Kinds: []string{"k"}, Retired: []string{"r"}, Logf: func(f string, a ...any) { mu.Lock(); logs = append(logs, fmt.Sprintf(f, a...)); mu.Unlock() }, Publish: func(_ context.Context, subject string, data []byte, _ string) error { mu.Lock() @@ -678,6 +704,23 @@ func subHeldWriterSeedsAtStart(t *testing.T) { if held := oh.Held(); len(held) != 1 || held[0].Kind != "k" { t.Fatalf("a writer of kinds [k] seeded %v", held) } + if e, _ := owned.Get("module.gone.r"); e != nil { + t.Fatal("the retired kind's key stays after Start") + } + mu.Lock() + clearedGone := slices.ContainsFunc(sent, func(e said) bool { + return e.subject == subjects.Cleared && strings.Contains(string(e.data), `"kind":"r"`) && strings.Contains(string(e.data), `"id":"gone"`) + }) + mu.Unlock() + if !clearedGone { + t.Fatalf("the retired key's clear is not said: %v", sent) + } + if got := read.read(); slices.Contains(got, "module.other.b") || slices.Contains(got, "module.gone.r") { + t.Fatalf("Start read keys not its own: %v", got) + } + if err := oh.Write(ctx, gone); err == nil { + t.Fatal("a write of a retired kind was taken") + } if err := oh.State(ctx, ""); err != nil { t.Fatalf("the statement of a writer over another bundle's key: %v", err) }