100 lines
3.5 KiB
Go
100 lines
3.5 KiB
Go
package agent
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"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's detail is a hold the node-engine judges again at a start, not one that waits for the
|
|
// operator's answer: its want's parts differ from its composition (§524) or its entry is not held (§421). 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", waiting for an answer nobody was asked.
|
|
func judgedAgain(why string) bool {
|
|
return strings.HasPrefix(why, PartsDiffer) || heldForEntry(why)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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) string {
|
|
if len(parts) == 0 {
|
|
return ""
|
|
}
|
|
fetched := map[string]bool{}
|
|
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:
|
|
if strings.HasPrefix(res.Image, "sha256:") {
|
|
fetched[res.Image] = true
|
|
} else if _, digest, ok := strings.Cut(res.Image, "@"); ok {
|
|
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, "; "))
|
|
}
|