jschoubben
d9e24e95a2
mesh/merge-gate pass: builds mesh-sdk, sent nowhere; no bus step; every machine composes with the change as it did without (4 of 4 compose)
mesh/repo-check pass: its merge-check.sh passed, each part in its toolchain: merge-check.sh (typescript), go/merge-check.sh (go)
mesh/delivery delivered
mesh/delivery-group group fix/365-a-tool-call-names-its-caller delivered: every member is delivered
The runtime names the caller it took from the subject a call arrived on in the call's _meta; stdio.CallerOf(args) hands it to the tool. Never read from the arguments, and Unproven when the runtime named none, so a bundle on an older runtime still says, explicitly, that its caller was not proven.
60 lines
2.2 KiB
Go
60 lines
2.2 KiB
Go
package stdio
|
|
|
|
import (
|
|
"reflect"
|
|
"regexp"
|
|
"sync"
|
|
"unsafe"
|
|
)
|
|
|
|
// Unproven is the caller of a call the runtime named no caller for: one that arrived on the subject that names
|
|
// none, or from a runtime that names none (novox/hq issue 365). Said as a word, never left empty, so a record
|
|
// shows it was not proven.
|
|
const Unproven = "unproven"
|
|
|
|
// MetaCaller is where in a `tools/call`'s `_meta` the runtime names the caller: the bus user that published the
|
|
// call, which the runtime takes from the subject the call arrived on — that subject's last token, which the
|
|
// bus lets each user publish with its own name alone (novox/hq issue 365, by ADR 0259 §3's precedent). The
|
|
// runtime writes `_meta`; a caller writes only `arguments`, so no caller can name another.
|
|
const MetaCaller = "mesh/caller"
|
|
|
|
// busUser is the shape of a bus user's name: `<node>.<module>`, `person.<name>`, `controller` — names whose
|
|
// parts are safe in a subject. Anything else the runtime named is not a caller and reads as Unproven.
|
|
var busUser = regexp.MustCompile(`^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*$`)
|
|
|
|
// calls holds the caller of every call while its tool runs, by the arguments map that call was handed.
|
|
var calls sync.Map // unsafe.Pointer → string
|
|
|
|
func argsKey(args map[string]any) unsafe.Pointer {
|
|
return reflect.ValueOf(args).UnsafePointer()
|
|
}
|
|
|
|
// CallerOf is who called the tool that was handed args, as the runtime proved it: the bus user that
|
|
// published the call, or Unproven. Read from the runtime, never from the arguments' contents — a `caller`
|
|
// argument names nobody. Valid while the tool runs; arguments no call was handed have no caller.
|
|
func CallerOf(args map[string]any) string {
|
|
if args == nil {
|
|
return Unproven
|
|
}
|
|
if c, ok := calls.Load(argsKey(args)); ok {
|
|
return c.(string)
|
|
}
|
|
return Unproven
|
|
}
|
|
|
|
// callerIn is the caller a `tools/call`'s `_meta` names, or Unproven.
|
|
func callerIn(meta map[string]any) string {
|
|
if s, ok := meta[MetaCaller].(string); ok && busUser.MatchString(s) {
|
|
return s
|
|
}
|
|
return Unproven
|
|
}
|
|
|
|
// runAs runs a tool with the caller held for its arguments for as long as it runs.
|
|
func runAs(t Tool, caller string, args map[string]any) (any, error) {
|
|
key := argsKey(args)
|
|
calls.Store(key, caller)
|
|
defer calls.Delete(key)
|
|
return t.Run(args)
|
|
}
|