The engine's Composed keeps the catalogue's Plan and the declaration types and goes through nodeengineclient's codec; the fingerprint key part is meshcatalogclient's. The candidate answer is nodeengine.CandidateAnswer; the have still holds it through an interim JSON bridge (link.interimAnswers) until the Have group moves. Claude-Session: https://claude.ai/code/session_01NcbgfFSnn24M3GcqttoU7i
89 lines
3.0 KiB
Go
89 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
engcomp "github.com/novox/mesh-host/internal/compositions"
|
|
"os"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/declaration"
|
|
|
|
"github.com/novox/mesh-host/internal/store"
|
|
)
|
|
|
|
// runsAsWritten is what the node runs as the composer reads it (selfcompose.Env.Running), with every file given by digest
|
|
// named as this node last wrote it, where the two differ (issue 924, novox 2026-10-29 01:16). What runs of a module the
|
|
// agent has not applied since its start can come from the kept declaration, older than the compositions applied since:
|
|
// its export (mesh-vault.kept) then named a digest the controller's sweep had removed, while the file on disk was the
|
|
// newer export the node wrote. A node composing its own carries such a file as it runs (mesh-sdk frombus keptOf), so it
|
|
// names what is on disk: **only when the node's record says it wrote exactly that content there** (store Applied.Wrote,
|
|
// Target), never a file someone else changed. A file that cannot be read, or that the record does not vouch for, is
|
|
// left as the composition names it.
|
|
func runsAsWritten(running []engcomp.Composed, statePath string) []engcomp.Composed {
|
|
if len(running) == 0 || statePath == "" {
|
|
return running
|
|
}
|
|
known, err := store.Load(statePath)
|
|
if err != nil {
|
|
return running
|
|
}
|
|
out := make([]engcomp.Composed, len(running))
|
|
for i, c := range running {
|
|
out[i] = c
|
|
var changed []json.RawMessage
|
|
for j, raw := range c.Resources {
|
|
if fixed, ok := asWritten(raw, known); ok {
|
|
if changed == nil {
|
|
changed = append([]json.RawMessage(nil), c.Resources...)
|
|
}
|
|
changed[j] = fixed
|
|
}
|
|
}
|
|
if changed != nil {
|
|
out[i].Resources = changed
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// asWritten is the file resource raw named by the digest and size of what this node last wrote at its path, when raw is a
|
|
// file given by another digest and the file there is what the record says the node wrote.
|
|
func asWritten(raw json.RawMessage, known store.State) (json.RawMessage, bool) {
|
|
var fields map[string]json.RawMessage
|
|
if json.Unmarshal(raw, &fields) != nil {
|
|
return nil, false
|
|
}
|
|
var kind, id, path, digest string
|
|
_ = json.Unmarshal(fields["type"], &kind)
|
|
_ = json.Unmarshal(fields["id"], &id)
|
|
_ = json.Unmarshal(fields["path"], &path)
|
|
_ = json.Unmarshal(fields["digest"], &digest)
|
|
if kind != string(declaration.TypeFile) || digest == "" || path == "" {
|
|
return nil, false
|
|
}
|
|
rec, ok := known.Find(id)
|
|
if !ok || rec.Wrote == "" || rec.Target != path {
|
|
return nil, false
|
|
}
|
|
body, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, false
|
|
}
|
|
sum := sha256.Sum256(body)
|
|
if hex.EncodeToString(sum[:]) != rec.Wrote {
|
|
return nil, false // changed since the node wrote it: not the node's to vouch for
|
|
}
|
|
if now := declaration.DigestOf(body); now == digest {
|
|
return nil, false
|
|
} else {
|
|
fields["digest"], _ = json.Marshal(now)
|
|
}
|
|
fields["size"], _ = json.Marshal(len(body))
|
|
fixed, err := json.Marshal(fields)
|
|
if err != nil {
|
|
return nil, false
|
|
}
|
|
return fixed, true
|
|
}
|