package build import ( "context" "crypto/sha256" "encoding/hex" "errors" "fmt" "time" occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel" "git.novox.be/novox/mesh-sdk/go/operatorask" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "mesh-delivery-builder/internal/versions" ) // **The operator is asked once a key's event builds are spent** (design 47 G §568, ADR 0673 §3): the seat operator-channel's ask, // level approve, with the options *Build once more* and *Leave it*, `about` the key so a newer ask replaces it (ADR 0666 §12), // naming the module, the fingerprint and the last error whole. *Build once more* builds one revision as a person's build // (BuildAgain, which starts the count again); *Leave it*, a decline or the ask's expiry leaves the key failed. // The ids of the ask's options. const ( OptionBuildOnceMore = "build-once-more" OptionLeaveIt = "leave-it" ) // AskLasts is how long the ask stays open: the longest an ask that approves may (the seat's own bound). const AskLasts = occ.ApproveLasts // askBuildBound is how long the builder waits for the claim and the asks of the build *Build once more* starts. const askBuildBound = 15 * time.Second // OperatorAsk asks the operator about a key and carries out the answer. type OperatorAsk struct { // Client keeps the builder's asks and the warrants it acted on in its state `asked`, checks each ask and holds each // warrant to the ask it answers; its Publish is Asker's. Client *occ.Client // Asker is mesh-sdk's asker on the seat operator-channel (design 47 G A-101): the ask published under the builder's own // name and the router's `decided` heard; no copy of it is the builder's. Asker *operatorask.Asker[oc.Warrant] // Acted keeps which key an ask was made for, beside the revision of the key it was made at (Retaker.Acted). Acted versions.ReserveStore Builder *Builder // Ctx is the builder's own context: the build a person's answer starts lives on it. Ctx context.Context Now func() time.Time Logf func(string, ...any) } func (o *OperatorAsk) logf(f string, a ...any) { if o.Logf != nil { o.Logf(f, a...) } } func (o *OperatorAsk) now() time.Time { if o.Now != nil { return o.Now() } return time.Now() } // AskID is the id of the ask about one revision of a key: the same revision is the same ask, a newer one a new ask. func AskID(key string, rev uint64) string { sum := sha256.Sum256([]byte(fmt.Sprintf("%s@%d", key, rev))) return "retake-" + hex.EncodeToString(sum[:16]) } // askedOf is the acted key of the key an ask was made for. func askedOf(id string) string { return versions.ActedKey("retake-ask:" + id) } // BuildOnceMoreAct is what *Build once more* binds: the verb and the key's module and fingerprint. func BuildOnceMoreAct(module, fingerprint string) occ.Act { return occ.Act{"verb": "build-again", "module": module, "fingerprint": fingerprint} } // Compose is the ask about key as it stands, at revision rev. func (o *OperatorAsk) Compose(key string, cur builds.BuilderBuild, rev uint64) (oc.Ask, error) { module, fp, err := builds.ParseBuilderBuildKey(key) if err != nil { return oc.Ask{}, err } binds, err := occ.ActDigest(BuildOnceMoreAct(module, fp)) if err != nil { return oc.Ask{}, err } headline := "Build " + module + " once more?" if r := []rune(headline); len(r) > occ.HeadlineLength { headline = string(r[:occ.HeadlineLength-1]) + "…" } last := []rune(cur.Error) if len(last) > 120 { last = append(last[:119], '…') } return oc.Ask{ID: AskID(key, rev), Headline: headline, Who: occ.Operator, About: key, Explanation: fmt.Sprintf("The build of %s failed on a transport fault, and events built it again %d times without it passing.\nLast error: %s", module, cur.EventBuilds, string(last)), Details: fmt.Sprintf("Key %s\nFingerprint %s\nLast error whole: %s", key, fp, cur.Error), Expires: occ.FormatTime(o.now().Add(AskLasts)), OnExpiry: "the key stays failed until builder_build_again or a new fingerprint", Options: []oc.Option{ {ID: OptionBuildOnceMore, Label: "Build once more", Does: "the builder builds this fingerprint once more, and counts the build as a person's", Level: occ.Approve, Binds: binds}, {ID: OptionLeaveIt, Label: "Leave it", Does: "nothing: the key stays failed", Level: occ.Acknowledge}, }}, nil } // Ask asks the operator about key at revision rev. The same revision asked twice is one ask. func (o *OperatorAsk) Ask(ctx context.Context, key string, cur builds.BuilderBuild, rev uint64) error { a, err := o.Compose(key, cur, rev) if err != nil { return err } k := askedOf(a.ID) if _, _, found, err := o.Acted.Get(ctx, k); err != nil { return err } else if !found { if _, err := o.Acted.Create(ctx, k, []byte(key)); err != nil && !errors.Is(err, versions.ErrConflict) { return err } } // An ask published and not marked asked (the write after it failed) is read again: it is one ask. if e, err := o.Client.State.Get("ask." + a.ID); err != nil { return err } else if e != nil { return nil } return o.Client.Ask(a) } // Listen hears the operator's answers through the sdk asker: each warrant of this builder's asks is acted on once. func (o *OperatorAsk) Listen() error { return o.Asker.Hear(func(w oc.Warrant) error { h, err := o.Client.Take(w, o.act) if h == "" && err != nil { return err // the state could not be reached: offered again } if err != nil { o.logf("the answer to the ask %s: %s: %v", w.Ask, h, err) return nil } o.logf("the answer to the ask %s: %s", w.Ask, h) return nil }) } // act carries out the option the operator chose: Build once more builds the key as a person's build, Leave it nothing. func (o *OperatorAsk) act(opt oc.Option, w oc.Warrant) error { if opt.ID != OptionBuildOnceMore { return nil } raw, _, found, err := o.Acted.Get(o.Ctx, askedOf(w.Ask)) if err != nil { return err } if !found { return fmt.Errorf("the builder holds no key the ask %s was made for", w.Ask) } module, fp, err := builds.ParseBuilderBuildKey(string(raw)) if err != nil { return err } o.logf("%s: the operator chose %s; built again as a person's build", raw, opt.Label) go func() { if res := o.Builder.BuildAgain(o.Ctx, module, fp, "the operator chose "+opt.Label, "operator-channel", askBuildBound); res.Refused != "" { o.logf("%s: not built again: %s", raw, res.Refused) } }() return nil }