package agent import ( "encoding/json" "fmt" "sort" "strings" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/containerimageregistryclient/reference" "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-sdk/go/declaration" ) // PartsDiffer is the start of the detail of a have held because a want's parts and the digests its composition fetches // disagree (design 47 G section 524). const PartsDiffer = "parts-differ:" // EntryAsked and EntryMissing open the detail of a have held for the entry the want names (design 47 G section 421 and // section 614): the entry is asked of the catalog half and not yet answered, or the half answered that it holds none. Both // are the phase held, and each names the fingerprint. const ( EntryAsked = "entry-asked:" EntryMissing = "entry-missing:" ) // judgedAgain says a held have is a hold the node-engine judges again at a start, not one that waits for the operator's answer: // its wait's reason (the structured field the have carries) is that its want's parts differ from its composition (§524) or its // entry is not held (§421), whatever words its detail opens with. Only a failed backup or restore point waits for an answer (ADR // 0568 §4); novox, 2026-11-16: the indexer held "parts-differ" was kept at a start as "held for a failed backup"; g14, 2026-11-18: // feh held "whether ..." with the reason entry-missing was kept the same way. func judgedAgain(h Have) bool { if h.Wait == nil { return false } switch h.Wait.Reason { case strings.TrimSuffix(PartsDiffer, ":"), strings.TrimSuffix(EntryAsked, ":"), strings.TrimSuffix(EntryMissing, ":"): return true } return false } // heldReason is the opening of a detail held for an entry: EntryAsked or EntryMissing. func heldReason(why string) string { if strings.HasPrefix(why, EntryAsked) { return EntryAsked } return EntryMissing } // heldForEntry says whether why is a hold for the entry a want names. func heldForEntry(why string) bool { return strings.HasPrefix(why, EntryAsked) || strings.HasPrefix(why, EntryMissing) } // upstreamCopy is whether a routed image is the registry seat's copy of an upstream image, `
/upstream//@`: // the mesh mirrors it, but it built nothing, so it is no part of a want (design 47 G A-454). func upstreamCopy(image string) bool { _, path, ok := strings.Cut(image, "/") if !ok { return false } _, _, upstream := reference.InUpstream(path) return upstream } // partsDifference checks a want's `parts` against the digests of the archive, process and container resources of the // composition, which are the digests the apply fetches and checks (design 47 G section 524). A want with no `parts` (an // assigner of before G, or a node whose record does not state `want-parts`) is applied as today: it returns "". With // `parts`, the want is applied only when the digest of every resource fetched is among the values of `parts` and every // value of `parts` is the digest of a resource fetched; otherwise it returns the detail naming each digest. func partsDifference(parts map[string]string, resources []json.RawMessage, templates []string) string { if len(parts) == 0 { return "" } inParts := map[string]bool{} for _, d := range parts { inParts[d] = true } fetched := map[string]bool{} // A templates archive the composition was rendered from was read from the artifact store and checked by its digest: // a part fetched (design 47 G A-481, A-481a). for _, d := range templates { fetched[d] = true } for _, raw := range resources { r, err := declaration.ParseResource(raw) if err != nil { continue } switch res := r.(type) { case *declaration.Archive: if res.Source != "" { fetched[res.Digest] = true } case *declaration.Process: // A runtime of its own runs the tool runner's program, which the tool runner's want checks (A-432). if res.Source != "" && !strings.HasSuffix(res.ID, "."+catalogue.OwnRuntimeID()) { fetched[res.Digest] = true } case *declaration.Container: // A digest the want's parts name always counts as fetched, whatever marks the resource carries; one they do not // name counts only when it is the mesh's own: an image the manifest pins from outside, or the registry seat's // copy of an upstream image, is no part (design 47 G A-454, A-454a). digest := "" if strings.HasPrefix(res.Image, "sha256:") { digest = res.Image } else if _, d, ok := strings.Cut(res.Image, "@"); ok { digest = d } if digest == "" { continue } if !inParts[digest] && (res.ImageSeat == "" || upstreamCopy(res.Image)) { continue } fetched[digest] = true } } named := map[string]bool{} for _, d := range parts { named[d] = true } var outside, missing []string for d := range fetched { if !named[d] { outside = append(outside, d) } } for d := range named { if !fetched[d] { missing = append(missing, d) } } if len(outside) == 0 && len(missing) == 0 { return "" } sort.Strings(outside) sort.Strings(missing) var said []string if len(outside) > 0 { said = append(said, "fetched and not in the want's parts: "+strings.Join(outside, ", ")) } if len(missing) > 0 { said = append(said, "in the want's parts and not fetched: "+strings.Join(missing, ", ")) } return fmt.Sprintf("%s %s", PartsDiffer, strings.Join(said, "; ")) }