When a module's ledger binding came or went, refreshRepairs stopped every subscription of its tools and served them all again, so a call in that gap was dropped the same way as on a membership (H-A-158). serve is now the one routine that changes a module's subscriptions, by tool address: it keeps those still named, subscribes the new, then stops those no longer named; refreshRepairs and the first serve both go through it, so no tool is served twice or not at all. The ledger test's later binding now comes and goes ten times, and the module's own tool must answer the first call after each, within the tests' 2 s bound; it failed without the change at GOMAXPROCS=1 and 24. Builds: design 47 H §774, H-A-158, H-A-160; principle 11
237 lines
11 KiB
Go
237 lines
11 KiB
Go
package runtime
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/buscalls"
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
"git.novox.be/novox/mesh-sdk/go/membership"
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/nats-io/nats.go/jetstream"
|
|
|
|
"github.com/novox/mesh-tools/node-tools/internal/bus"
|
|
"github.com/novox/mesh-tools/node-tools/internal/launch"
|
|
mt "github.com/novox/mesh-tools/node-tools/internal/meshtest"
|
|
)
|
|
|
|
// 1966/AC16: given a module with a ledger binding, when the runner lists its tools, then the four repair tools are
|
|
// among them, marked acts or reads; a module without one has none, and a binding written later brings them.
|
|
func TestTheLedgerRepairsAreToolsOfEveryLedgerOwner(t *testing.T) {
|
|
mesh := mt.New(t)
|
|
owner := mt.MembershipOf("owner", "anchor", true, nil)
|
|
owner.Bindings = []membership.BusBinding{{Local: "records", Storage: catalogue.StorageLedger, Template: catalogue.TemplateLedger,
|
|
History: "LEDGER_owner_records", Subject: "mesh.ledger.owner.records.history", State: "owner_records",
|
|
Snapshot: "mesh.ledger.owner.records.snapshot"}}
|
|
plain := mt.MembershipOf("plain", "anchor", true, nil)
|
|
mesh.Issue(t, owner)
|
|
mesh.Issue(t, plain)
|
|
nodeTools := connect(t, "node-tools", "anchor")
|
|
stop, err := Run(nodeTools, []Served{{"owner", []string{mt.Fixture("caller-echo.py")}},
|
|
{"plain", []string{mt.Fixture("caller-echo.py")}}}, nil, func(string, ...any) {})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer stop()
|
|
asker := connect(t, "console", "workstation")
|
|
listed := func(module string) (string, error) {
|
|
answered, err := asker.AskWithin(module+"."+ToolsVerb, map[string]any{}, "", callWithin)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var got ToolsAnswer
|
|
if err := json.Unmarshal(answered.Result, &got); err != nil {
|
|
return "", err
|
|
}
|
|
var names []string
|
|
for _, tool := range got.Tools {
|
|
names = append(names, tool.Name+":"+tool.Effect)
|
|
}
|
|
sort.Strings(names)
|
|
return strings.Join(names, " "), nil
|
|
}
|
|
for _, c := range []struct{ name, module, want string }{
|
|
{"a ledger owner lists the four repairs", "owner", "ledger_lag:reads ledger_rebuild:acts ledger_reindex:acts ledger_snapshot:acts who:"},
|
|
{"a module with no ledger has none", "plain", "who:"},
|
|
} {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
var got string
|
|
mt.Until(t, func() (err error) { got, err = listed(c.module); return })
|
|
if got != c.want {
|
|
t.Fatalf("%s lists %q, want %q", c.module, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
t.Run("a ledger bound later brings them", func(t *testing.T) {
|
|
// Its own tool answers the first call after each binding comes or goes: the repairs' refresh keeps the
|
|
// subscriptions it still names (design 47 H, H-A-160).
|
|
for round := 1; round <= 10; round++ {
|
|
plain.Bindings = nil
|
|
if round%2 == 1 {
|
|
plain.Bindings = owner.Bindings
|
|
}
|
|
mesh.Issue(t, plain)
|
|
if _, err := asker.AskWithin("plain.who@anchor", map[string]any{}, "", callWithin); err != nil {
|
|
t.Fatalf("binding change %d: the first call of plain.who failed: %v — dropped while its tools were served again", round, err)
|
|
}
|
|
}
|
|
plain.Bindings = owner.Bindings
|
|
mesh.Issue(t, plain)
|
|
mt.Until(t, func() error {
|
|
got, err := listed("plain")
|
|
if err == nil && !strings.Contains(got, "ledger_rebuild:acts") {
|
|
err = errors.New("listed " + got)
|
|
}
|
|
return err
|
|
})
|
|
})
|
|
}
|
|
|
|
// aLedger raises one ledger of module m on the bus as the bus module would create it, binds it in m's membership, and
|
|
// answers the runtime's buses for m and for other; its types travel on its binding, and a second binding carries none.
|
|
func aLedger(t *testing.T) (m, other *moduleBus, mesh *mt.Mesh) {
|
|
t.Helper()
|
|
mesh = mt.New(t)
|
|
nc, err := nats.Connect(mt.URL(t))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(nc.Close)
|
|
js, _ := jetstream.New(nc)
|
|
ctx := context.Background()
|
|
for _, cfg := range []jetstream.StreamConfig{
|
|
{Name: "LEDGER_m_records", Subjects: []string{"mesh.ledger.m.records.history.>"}},
|
|
{Name: "SNAPSHOT_m_records", Subjects: []string{"mesh.ledger.m.records.snapshot.>"}, MaxMsgsPerSubject: 1},
|
|
} {
|
|
if _, err := js.CreateStream(ctx, cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: "m_records"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mem := mt.MembershipOf("m", "anchor", false, nil)
|
|
mem.Bindings = []membership.BusBinding{{Local: "records", Storage: catalogue.StorageLedger, Template: catalogue.TemplateLedger,
|
|
History: "LEDGER_m_records", Subject: "mesh.ledger.m.records.history", State: "m_records", Snapshot: "mesh.ledger.m.records.snapshot",
|
|
Types: []catalogue.LedgerType{{Name: "decision", Schema: map[string]catalogue.LedgerField{"title": {Type: "string"}},
|
|
Operations: []catalogue.LedgerOperation{{Name: "title", Effect: catalogue.EffectSetFields, Fields: []string{"title"}, Author: true}}}}},
|
|
{Local: "untyped", Storage: catalogue.StorageLedger, Template: catalogue.TemplateLedger, History: "LEDGER_m_records",
|
|
State: "m_records"},
|
|
{Local: "elsewhere", Storage: catalogue.StorageLedger, Template: catalogue.TemplateLedger, History: "LEDGER_m_records",
|
|
Subject: "mesh.ledger.m.records.history", State: "m_records", Types: []catalogue.LedgerType{{Name: "decision"}}}}
|
|
mesh.Issue(t, mem)
|
|
mesh.Issue(t, mt.MembershipOf("other", "anchor", false, nil))
|
|
conn := connect(t, "node-tools", "anchor")
|
|
conn.Follow("m")
|
|
conn.Follow("other")
|
|
mt.Until(t, func() error {
|
|
if conn.Membership("m") == nil || conn.Membership("other") == nil {
|
|
return errors.New("not issued yet")
|
|
}
|
|
return nil
|
|
})
|
|
all := &consumers{conn: conn, logf: t.Logf, of: map[string]*moduleEvents{}, ledgers: ledgerSource{
|
|
writer: func(string) (*bus.Conn, error) { return conn, nil },
|
|
}}
|
|
return all.forModule("m").(*moduleBus), all.forModule("other").(*moduleBus), mesh
|
|
}
|
|
|
|
// 1966/AC17, 1966/AC18: the author an apply is stamped with is the caller the runtime proved for the call in flight it
|
|
// names, whatever author the bundle wrote; another module's call, or one not in flight, is refused naming it (ADR 0597 §7).
|
|
func TestAnApplyIsStampedWithTheCallerTheRuntimeProved(t *testing.T) {
|
|
m, other, _ := aLedger(t)
|
|
call, end := m.Begin("op@shanks")
|
|
defer end()
|
|
theirs, endTheirs := other.Begin("op@shanks")
|
|
defer endTheirs()
|
|
forged := `"body":{"title":"T","author":{"account":"x","caller":"forged"}}`
|
|
for _, c := range []struct{ name, params, caller, refusal string }{
|
|
{"1966/AC17 a call in flight stamps its proven caller", `{"ledger":"records","instance":"decision/1","operation":"title",` + forged + `,"call":"` + call + `","author":"forged"}`, "op@shanks", ""},
|
|
{"naming no call stamps the account alone", `{"ledger":"records","instance":"decision/2","operation":"title",` + forged + `}`, "", ""},
|
|
{"1966/AC18 another module's call is refused, naming it", `{"ledger":"records","instance":"decision/3","operation":"title",` + forged + `,"call":"` + theirs + `"}`, "", "the call " + theirs + ", which is another module's"},
|
|
{"a ledger bound with no types is refused, naming it", `{"ledger":"untyped","instance":"decision/3","operation":"title",` + forged + `}`, "", `m's ledger "untyped" is bound with no types`},
|
|
{"a binding naming subjects its account is not granted is refused, naming both", `{"ledger":"elsewhere","instance":"decision/3","operation":"title",` + forged + `}`, "", "bound with the history subject mesh.ledger.m.records.history, and its ledger account is granted mesh.ledger.m.elsewhere.history alone"},
|
|
{"a call not in flight is refused, naming it", `{"ledger":"records","instance":"decision/3","operation":"title",` + forged + `,"call":"c0ffee"}`, "", "the call c0ffee, which is not a tool call in flight"},
|
|
} {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
var req struct {
|
|
Instance string `json:"instance"`
|
|
}
|
|
_ = json.Unmarshal([]byte(c.params), &req)
|
|
_, err := m.BusState(buscalls.LedgerApply, json.RawMessage(c.params))
|
|
if c.refusal != "" {
|
|
if err == nil || !strings.Contains(err.Error(), c.refusal) {
|
|
t.Fatalf("applied with %v, want refused with %q", err, c.refusal)
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
raw, err := m.BusState(buscalls.LedgerHistory, json.RawMessage(`{"ledger":"records","instance":"`+req.Instance+`"}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var page buscalls.HistoryPage
|
|
_ = json.Unmarshal(raw, &page)
|
|
if len(page.Operations) != 1 || page.Operations[0].Author != (buscalls.Author{Account: "m", Caller: c.caller}) {
|
|
t.Fatalf("the history holds %+v, want the author {m %s}", page.Operations, c.caller)
|
|
}
|
|
state, _ := m.BusState(buscalls.LedgerGet, json.RawMessage(`{"ledger":"records","instance":"`+req.Instance+`"}`))
|
|
if !strings.Contains(string(state), `"author":{"account":"m"`) || strings.Contains(string(state), "forged") {
|
|
t.Fatalf("the state took the bundle's author: %s", state)
|
|
}
|
|
})
|
|
}
|
|
end()
|
|
if _, err := m.BusState(buscalls.LedgerApply, json.RawMessage(`{"ledger":"records","instance":"decision/4","operation":"title","call":"`+call+`"}`)); err == nil {
|
|
t.Fatal("a call that ended was still taken as in flight")
|
|
}
|
|
}
|
|
|
|
// issue 1966 TLS-2: a bundle's tool named as one of the runner's ledger repairs is refused at the load, naming the tool and the
|
|
// repair; any other name is served.
|
|
func TestABundleToolNamedAsALedgerRepairIsRefused(t *testing.T) {
|
|
for _, c := range []struct{ name, tool, want string }{
|
|
{"rebuild", RepairRebuild, "m's bundle serves a tool named ledger_rebuild, which is also the ledger repair the runner serves for m"},
|
|
{"reindex", RepairReindex, "ledger_reindex"},
|
|
{"snapshot", RepairSnapshot, "ledger_snapshot"},
|
|
{"lag", RepairLag, "ledger_lag"},
|
|
{"another name", "ledger_status", ""},
|
|
} {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := repairClash("m", []launch.Tool{{Name: "first"}, {Name: c.tool}})
|
|
if (c.want == "") != (got == "") || !strings.Contains(got, c.want) {
|
|
t.Errorf("clash %q, want one containing %q", got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// issue 1966 TLS-3: every method of a capability the runner states is a call it answers, and the two states its calls under
|
|
// no other name; none answers "the runtime answers no ...".
|
|
func TestEveryCallOfAStatedCapabilityIsAnswered(t *testing.T) {
|
|
m, _, _ := aLedger(t)
|
|
if got := strings.Join(CallCapabilities(), ","); got != "approval-mark/1,bus-state-calls,finding-calls,ledger-calls,ledger-upkeep-calls,put-sessions,seat-settle-delay,sent-objects-calls,stream-publish" {
|
|
t.Fatalf("the runner states %s", got)
|
|
}
|
|
for capability, methods := range callFamilies {
|
|
for _, method := range methods {
|
|
t.Run(capability+" "+method, func(t *testing.T) {
|
|
_, err := m.BusState(method, json.RawMessage(`"not a request"`))
|
|
if err != nil && strings.Contains(err.Error(), "the runtime answers no") {
|
|
if stop, werr := m.BusStateWatch(method, json.RawMessage(`"not a request"`), func(json.RawMessage) error { return nil }); werr != nil && strings.Contains(werr.Error(), "the runtime answers no") {
|
|
t.Errorf("%s is stated under %s and answered by neither BusState nor BusStateWatch", method, capability)
|
|
} else if stop != nil {
|
|
stop()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|