Perform what mesh-sdk's composition names foreseen, and compose a send over the SDK: perform, composeSend, composeQuestion, resolveNode (issues 1385, 1386)
A composition over the Input makes nothing; a send performs what it named (the pair credentials no row holds, the seats to pass, the ports and own secrets, the core credentials asked of the vault every send, the certificate), reads the stores again and composes again, and refuses a declaration that still stands in for a value anywhere in its body. A question (composeQuestion) never performs. The operation's Input is read once and kept in its context until a send changes what it read, per what the context keeps (recorded builds, the grants step, a settings walk). A core credential the vault did not answer for and no box is kept for refuses the send, where the controller sealed it itself (ADR 0396): the composition has no such fallback (reported). Callers switch in the next commits.
This commit is contained in:
@@ -0,0 +1,260 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
"git.novox.be/novox/mesh-sdk/go/compose"
|
||||
)
|
||||
|
||||
// The controller's composition on mesh-sdk's (novox/hq ADR 0453 clause 3, design 47 R4b, issues 1386 to 1388): every
|
||||
// caller that planned or composed a node reads the Input once for its operation (compose_input.go), asks the SDK to
|
||||
// compose over it, and, when it sends, performs what the composition names foreseen (compose_perform.go) and composes again.
|
||||
|
||||
// inputCacheKey carries an operation's Input in its context, so the planning of every node of one verb reads the stores once.
|
||||
type inputCacheKey struct{}
|
||||
|
||||
type inputCache struct {
|
||||
mu sync.Mutex
|
||||
by map[string]*meshInput
|
||||
}
|
||||
|
||||
// withInputCache is ctx for an operation: the Input read for it is kept until a send changes what it read. A context that
|
||||
// carries none reads the stores for each composition, which is correct and slow.
|
||||
func withInputCache(ctx context.Context) context.Context {
|
||||
if _, ok := ctx.Value(inputCacheKey{}).(*inputCache); ok {
|
||||
return ctx
|
||||
}
|
||||
return context.WithValue(ctx, inputCacheKey{}, &inputCache{by: map[string]*meshInput{}})
|
||||
}
|
||||
|
||||
// keptSignature is what the Input read depends on in ctx: which recorded modules each machine keeps at the build it runs
|
||||
// (recorded_kept.go), so an Input read for a person's push is never taken for one read for a gated send.
|
||||
func keptSignature(ctx context.Context) string {
|
||||
skip, on := keptExcept(ctx)
|
||||
var names []string
|
||||
for m := range skip {
|
||||
names = append(names, m)
|
||||
}
|
||||
sort.Strings(names)
|
||||
every, _ := ctx.Value(keepEveryBuildKey{}).(string)
|
||||
settings, _ := ctx.Value(keepForSettingsKey{}).(string)
|
||||
return fmt.Sprintf("kept=%v;except=%v;every=%s;settings=%s", on, names, every, settings)
|
||||
}
|
||||
|
||||
// inputFor is the Input for ctx's operation.
|
||||
func inputFor(ctx context.Context, open *stores) (*meshInput, error) {
|
||||
cache, ok := ctx.Value(inputCacheKey{}).(*inputCache)
|
||||
if !ok {
|
||||
return readComposeInput(ctx, open)
|
||||
}
|
||||
sig := keptSignature(ctx)
|
||||
cache.mu.Lock()
|
||||
defer cache.mu.Unlock()
|
||||
if in := cache.by[sig]; in != nil {
|
||||
return in, nil
|
||||
}
|
||||
in, err := readComposeInput(ctx, open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
cache.by[sig] = in
|
||||
return in, nil
|
||||
}
|
||||
|
||||
// forgetInput drops what the operation read, because a send made or recorded something it read.
|
||||
func forgetInput(ctx context.Context) {
|
||||
if cache, ok := ctx.Value(inputCacheKey{}).(*inputCache); ok {
|
||||
cache.mu.Lock()
|
||||
cache.by = map[string]*meshInput{}
|
||||
cache.mu.Unlock()
|
||||
}
|
||||
}
|
||||
|
||||
// resolveNode works out everything a node should run, from what was assigned to it (planFor on the SDK): over the Input,
|
||||
// writing nothing. A failure to compose the node's own modules is marked notResolvable, as planFor marked it; every other
|
||||
// failure is returned as it is.
|
||||
func resolveNode(ctx context.Context, open *stores, node string) (catalogue.Resolution, catalogue.SettingsBy, error) {
|
||||
in, err := inputFor(ctx, open)
|
||||
if err != nil {
|
||||
return catalogue.Resolution{}, nil, err
|
||||
}
|
||||
resolved, err := compose.Resolve(in.Input, node)
|
||||
if err != nil {
|
||||
if compose.IsUnresolvable(err) {
|
||||
return catalogue.Resolution{}, nil, notResolvable{err}
|
||||
}
|
||||
return catalogue.Resolution{}, nil, err
|
||||
}
|
||||
logUnheld(node, resolved.Plan.Unheld)
|
||||
return resolved.Plan, resolved.Settings, nil
|
||||
}
|
||||
|
||||
// generatorsOf is what every node's declaration is composed with, over the whole mesh (generators on the SDK).
|
||||
func generatorsOf(ctx context.Context, open *stores) (map[string]catalogue.Generator, error) {
|
||||
in, err := inputFor(ctx, open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return compose.Generators(in.Input)
|
||||
}
|
||||
|
||||
// composeQuestion composes a node's declaration as a question asks it: nothing is made, and what a send would make is a
|
||||
// stand-in (Foreseeing) or left out (Reading). It also answers what the node-engine's validator refuses of it. The lines the
|
||||
// composition found are said where the controller says its own (standard error, or the writer an act gave).
|
||||
//
|
||||
// withOrder says the declaration carries the order it was last sent under (composedAndValidated's, which a comparison with the
|
||||
// last send needs); without it the order is none, as declarationWith left it for the sender to stamp.
|
||||
func composeQuestion(ctx context.Context, open *stores, node string, mode compose.Mode, withOrder bool) (sendable, []string, error) {
|
||||
in, err := inputFor(ctx, open)
|
||||
if err != nil {
|
||||
return sendable{}, nil, err
|
||||
}
|
||||
d, problems, err := compose.ComposeIn(in.Input, node, mode)
|
||||
if err != nil {
|
||||
return sendable{}, nil, markUnresolvable(err)
|
||||
}
|
||||
sayFound(ctx, d)
|
||||
out := sendableOf(d)
|
||||
if !withOrder {
|
||||
out.Sequence, out.Epoch, out.Generation = 0, 0, 0
|
||||
}
|
||||
return out, problems, nil
|
||||
}
|
||||
|
||||
// markUnresolvable is an error of a node whose own set does not compose, as planFor marked it.
|
||||
func markUnresolvable(err error) error {
|
||||
if compose.IsUnresolvable(err) {
|
||||
return notResolvable{err}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// composeSend composes a node's declaration to send it, as the Allocating composition did: composed over what is read,
|
||||
// then what it named foreseen is made (perform), the stores are read again and it is composed again. A declaration that
|
||||
// still names anything foreseen is refused, said, and never sent.
|
||||
func composeSend(ctx context.Context, open *stores, node string) (sendable, error) {
|
||||
for attempt := 0; ; attempt++ {
|
||||
in, err := inputFor(ctx, open)
|
||||
if err != nil {
|
||||
return sendable{}, err
|
||||
}
|
||||
d, _, err := compose.ComposeIn(in.Input, node, compose.Foreseeing)
|
||||
if err != nil {
|
||||
return sendable{}, markUnresolvable(err)
|
||||
}
|
||||
left := stillForeseen(d)
|
||||
resolved, rerr := compose.Resolve(in.Input, node)
|
||||
if rerr != nil {
|
||||
return sendable{}, markUnresolvable(rerr)
|
||||
}
|
||||
if len(resolved.Foreseen) > 0 {
|
||||
left = append(left, resolved.Foreseen...)
|
||||
}
|
||||
if len(left) == 0 && len(in.wouldMake) == 0 {
|
||||
sayFound(ctx, d)
|
||||
out := sendableOf(d)
|
||||
// The sender stamps the order it allots (order.stamp); a composition for a send carries none of its own.
|
||||
out.Sequence, out.Epoch, out.Generation = 0, 0, 0
|
||||
here, _ := nodeOf(in.Input, node)
|
||||
out.Builds = buildsOf(in.Input, here, resolved.Plan, d.LeftOutWhy)
|
||||
out.Bindings = boundToData(resolved.Plan, d.LeftOutWhy)
|
||||
if len(d.Filled) > 0 {
|
||||
if out.plans, err = handedPlans(in, node, resolved); err != nil {
|
||||
return sendable{}, err
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
if attempt > 0 {
|
||||
return sendable{}, fmt.Errorf("%s was composed twice and still names what only a send makes (%s): nothing is sent "+
|
||||
"that stands in for a value", node, strings.Join(left, "; "))
|
||||
}
|
||||
if _, err := perform(ctx, open, in, node, d); err != nil {
|
||||
return sendable{}, err
|
||||
}
|
||||
// What was made is in the stores now: the next read is a fresh one.
|
||||
forgetInput(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
// sayFound says the lines a composition found while composing, once each: a machine left out of the rest of the mesh, a seat
|
||||
// that two claimants could take, the bus's users left out for want of a credential.
|
||||
func sayFound(ctx context.Context, d compose.Declared) {
|
||||
if len(d.Said) == 0 {
|
||||
return
|
||||
}
|
||||
var w io.Writer = os.Stderr
|
||||
if lw, ok := ctx.Value(leftOutKey{}).(io.Writer); ok {
|
||||
w = lw
|
||||
}
|
||||
for _, line := range d.Said {
|
||||
fmt.Fprintln(w, line)
|
||||
}
|
||||
}
|
||||
|
||||
// sendableOf is a composed declaration as the controller's sends know it.
|
||||
func sendableOf(d compose.Declared) sendable {
|
||||
out := sendable{Resources: d.Resources, Sequence: d.Sequence, Epoch: d.Epoch, Generation: d.Generation,
|
||||
ReadsModules: d.ReadsModules, moduleOf: d.ModuleOf, buildIDs: d.BuildIDs, modules: d.Modules,
|
||||
localNetwork: d.LocalNetwork, Received: d.Received, Mesh: d.Mesh, BusUsers: d.BusUsers,
|
||||
LeftOut: d.LeftOut, leftOutWhy: d.LeftOutWhy, withheld: d.Withheld, unbound: d.Unbound, foreseen: d.Foreseen,
|
||||
unplaced: d.Unplaced, handedOnly: d.HandedOnly, Filled: d.Filled, Provisioner: d.Provisioner,
|
||||
requiredBy: d.RequiredBy}
|
||||
if d.Adoption != nil {
|
||||
out.Adoption = &adoptionEnvelope{Taken: d.Adoption.Taken, Untaken: d.Adoption.Untaken}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// buildsOf is the build of each module a declaration for the node carries, as a send records it (novox/hq issue 259): the
|
||||
// module's current build for each module in it, the build it was last sent for one left out of it, and a module kept at the
|
||||
// build the machine runs carried at that one (ADR 0245). Never nil.
|
||||
func buildsOf(in compose.Input, node compose.Node, plan catalogue.Resolution, leftOut map[string]string) map[string]string {
|
||||
before := node.SentBuilds
|
||||
if !node.SentKnown {
|
||||
before = nil
|
||||
}
|
||||
out := map[string]string{}
|
||||
for _, m := range plan.Modules {
|
||||
if _, left := leftOut[m.Module]; left {
|
||||
if was, kept := before[m.Module]; kept {
|
||||
out[m.Module] = was
|
||||
}
|
||||
continue
|
||||
}
|
||||
out[m.Module] = in.CurrentBuilds[m.Module]
|
||||
}
|
||||
for m, was := range node.KeptBuilds {
|
||||
if _, carried := out[m]; carried {
|
||||
out[m] = was
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// handedPlans is the plan of each module handed to the provisioner, which the assignments mirror keeps with the send (design
|
||||
// 57 P6): the composition's declaration does not carry it, so it is composed from the same rendering again.
|
||||
func handedPlans(in *meshInput, node string, resolved compose.Resolved) (map[string]catalogue.Plan, error) {
|
||||
rendered, err := compose.Render(in.Input, node, compose.Foreseeing)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
gens, err := compose.Generators(in.Input)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
with := rendered.Rendering
|
||||
with.Generators = gens
|
||||
composed, err := resolved.Plan.Compose(with)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return composed.Plans, nil
|
||||
}
|
||||
Reference in New Issue
Block a user