Indexer: a head the source names with no merged message, or none it can read, is read whole through the seat git and taken in as a merge of every file of its tree, with its templates' needs and the predefined list (A-401, A-402)
Builds: design 47 G A-401, A-402, A-93, A-85
This commit is contained in:
@@ -11,6 +11,7 @@ import (
|
||||
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery"
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
)
|
||||
|
||||
// Design 47 G §13, §14, §291, A-93: a watched branch other than the first is taken in as a pure computation from the merged
|
||||
@@ -111,3 +112,117 @@ func TestABranchTakeInKeepsNoRevisionWithARefusedCycle(t *testing.T) {
|
||||
t.Errorf("the journal %q does not say the cycle %s", logs.String(), want)
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G A-401, A-93: a head the source names that has no merged message (a branch newly watched) is read whole at that
|
||||
// commit through the seat git and taken in as a merge of every file of its tree, so the branch keeps its first revision;
|
||||
// a head with a merged message is taken in as before and the seat git is not asked.
|
||||
func TestAHeadWithNoMergedMessageIsReadWholeAtItsCommit(t *testing.T) {
|
||||
for _, row := range []struct {
|
||||
name string
|
||||
hasMessage bool
|
||||
readFails bool
|
||||
wantRevision bool
|
||||
wantRead bool
|
||||
}{
|
||||
{name: "no merged message: read whole", wantRevision: true, wantRead: true},
|
||||
{name: "a merged message: taken in as before", hasMessage: true, wantRevision: true},
|
||||
{name: "no merged message and the seat git cannot read it: no revision", readFails: true, wantRead: true},
|
||||
} {
|
||||
t.Run(row.name, func(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
ix, _, merged := newFormIndexerUnmerged(t, builderModules(t)...)
|
||||
ix.Revisions = newMemObjects(0)
|
||||
ix.Graph = newMem()
|
||||
var logs strings.Builder
|
||||
ix.Logf = func(format string, args ...any) { fmt.Fprintf(&logs, format+"\n", args...) }
|
||||
ix.Message = func(context.Context, string, string, int) ([]byte, error) {
|
||||
if !row.hasMessage {
|
||||
return nil, fmt.Errorf("the forge gives no merged pull request")
|
||||
}
|
||||
return json.Marshal(merged)
|
||||
}
|
||||
reads := 0
|
||||
ix.ReadFile = func(context.Context, string, string, string) ([]byte, error) { return nil, nil } // no predefined list
|
||||
ix.Read = func(_ context.Context, _, sha, dir string) (RepoRead, error) {
|
||||
reads++
|
||||
if row.readFails || sha != merged.Merge {
|
||||
return RepoRead{}, fmt.Errorf("the seat git does not answer")
|
||||
}
|
||||
r := RepoRead{Root: merged.Root, Trees: merged.Trees, Manifests: map[string]string{}, Locks: map[string]map[string]string{}, Packages: map[string][]string{}}
|
||||
if _, ok := merged.Trees[dir]; ok {
|
||||
r.Manifests[dir], r.Locks[dir], r.Packages[dir] = merged.Manifests[dir], merged.Locks[dir], merged.Packages[dir]
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
answer := meshdelivery.SourceAnswer{Branch: "beta", Revision: 9, Repositories: []meshdelivery.SourceHead{{Repository: catalogueRepo, Head: merged.Merge, Trunk: "beta"}}}
|
||||
if err := ix.ApplyBranchSource(ctx, "beta", answer); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if (reads > 0) != row.wantRead {
|
||||
t.Errorf("the seat git was asked %d times, want asked: %v", reads, row.wantRead)
|
||||
}
|
||||
rev, entries, err := ReadRevision(ctx, ix.Revisions, BranchObject("beta", 1))
|
||||
if (err == nil) != row.wantRevision {
|
||||
t.Fatalf("branch.beta.1 read: %v, want a revision: %v", err, row.wantRevision)
|
||||
}
|
||||
if row.wantRevision && (rev.Branch != "beta" || len(entries) != len(builderModules(t))) {
|
||||
t.Errorf("branch.beta.1 = %+v with %d entries, want every module", rev, len(entries))
|
||||
}
|
||||
if said := strings.Contains(logs.String(), "has no merged message"); said != row.wantRead {
|
||||
t.Errorf("the journal %q says the whole read: %v, want %v", logs.String(), said, row.wantRead)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G A-401, A-402: the message a head read whole gives equals the forge bridge's: a templated module's needs
|
||||
// include its template's text (ADR 0632 §2), and the catalogue's predefined list is carried, or said absent.
|
||||
func TestAHeadReadWholeCarriesTheTemplateNeedsAndThePredefinedList(t *testing.T) {
|
||||
templated := strings.Replace(catalogueManifest(t, "avahi"), `"resources": [`, `"resources": [
|
||||
{"id": "conf", "type": "file", "path": "/etc/avahi-x.conf", "template": "files/x.conf"},`, 1)
|
||||
for _, row := range []struct {
|
||||
name string
|
||||
template []byte // nil: the forge has no such file
|
||||
predefined []byte
|
||||
wantNeeds bool
|
||||
wantList string
|
||||
wantNotFound bool
|
||||
}{
|
||||
{name: "template and predefined list", template: []byte("host=${seat:node-service-manager:reach}"), predefined: []byte(`{"a":1}`), wantNeeds: true, wantList: `{"a":1}`},
|
||||
{name: "no template file and no list", wantNotFound: true},
|
||||
} {
|
||||
t.Run(row.name, func(t *testing.T) {
|
||||
ix, _, merged := newFormIndexerUnmerged(t, mod{name: "avahi", manifest: templated})
|
||||
ix.ReadFile = func(_ context.Context, repository, sha, p string) ([]byte, error) {
|
||||
if repository != catalogueRepo || sha != merged.Merge {
|
||||
return nil, fmt.Errorf("unexpected read of %s at %s", repository, sha)
|
||||
}
|
||||
switch p {
|
||||
case "modules/avahi/files/x.conf":
|
||||
return row.template, nil
|
||||
case "predefined.json":
|
||||
return row.predefined, nil
|
||||
}
|
||||
return nil, fmt.Errorf("unexpected file %s", p)
|
||||
}
|
||||
ix.Read = func(_ context.Context, _, _, dir string) (RepoRead, error) {
|
||||
return RepoRead{Root: merged.Root, Trees: merged.Trees, Manifests: map[string]string{dir: merged.Manifests[dir]}, Locks: map[string]map[string]string{dir: merged.Locks[dir]}}, nil
|
||||
}
|
||||
f, err := ix.wholeAt(context.Background(), catalogueRepo, merged.Merge)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
text := map[string]string{}
|
||||
if row.template != nil {
|
||||
text["files/x.conf"] = string(row.template)
|
||||
}
|
||||
want, _ := catalogue.ModuleNeeds([]byte(templated), text)
|
||||
if got := f.Needs["modules/avahi"]; !slices.Equal(got, want) || (row.wantNeeds && !slices.Contains(got, catalogue.ReadForm+catalogue.ReferenceFormSeatReach)) {
|
||||
t.Errorf("needs %v, want %v", got, want)
|
||||
}
|
||||
if string(f.Predefined) != row.wantList || f.PredefinedRead != row.wantNotFound {
|
||||
t.Errorf("predefined %q (read-absent %v), want %q (%v)", f.Predefined, f.PredefinedRead, row.wantList, row.wantNotFound)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,13 +2,17 @@ package index
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"maps"
|
||||
"path"
|
||||
"slices"
|
||||
"strings"
|
||||
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
"git.novox.be/novox/mesh-sdk/go/keys"
|
||||
"git.novox.be/novox/mesh-sdk/go/process"
|
||||
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient"
|
||||
@@ -196,6 +200,12 @@ func (ix *Indexer) takeInHeads(ctx context.Context, heads map[string]string) []s
|
||||
continue
|
||||
}
|
||||
f, err := ix.mergedAt(ctx, repository, head)
|
||||
if err != nil && ctx.Err() == nil && ix.Read != nil {
|
||||
// A head the source names that has no merged message (a branch newly watched, whose head no merge on it made) is
|
||||
// read whole at that commit, as a clone does (A-401, A-93).
|
||||
ix.logf("catalog graph: %s at %.12s has no merged message (%v): read whole at that commit through the seat git, as a merge of every file of its tree", repository, head, err)
|
||||
f, err = ix.wholeAt(ctx, repository, head)
|
||||
}
|
||||
if err == nil {
|
||||
_, err = ix.ApplyMessage(ctx, f)
|
||||
}
|
||||
@@ -258,3 +268,92 @@ func (ix *Indexer) mergedAt(ctx context.Context, repository, head string) (forge
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
// wholeAt is the merged message of a head that has none (A-401): the head's tree and files read through the seat git
|
||||
// (Read), every module directory of it with its manifest, lock files and mesh packages, as a merge whose changed files are
|
||||
// every file of that tree, so it is computed as any other head (applyMoving; A-93).
|
||||
func (ix *Indexer) wholeAt(ctx context.Context, repository, head string) (forgemsg.Forge, error) {
|
||||
f := forgemsg.Forge{V: keys.Version, Kind: forgemsg.ForgeMerged, Repository: repository, Merge: head, Head: head}
|
||||
file := func(p string) ([]byte, error) {
|
||||
if ix.ReadFile == nil {
|
||||
return nil, errors.New("the indexer reads no file of the forge")
|
||||
}
|
||||
return ix.ReadFile(ctx, repository, head, p)
|
||||
}
|
||||
first, err := ix.Read(ctx, repository, head, "")
|
||||
if err != nil {
|
||||
return f, fmt.Errorf("the seat git could not read %s at %.12s: %w", repository, head, err)
|
||||
}
|
||||
f.Root, f.Trees = first.Root, maps.Clone(first.Trees)
|
||||
for _, dir := range slices.Sorted(maps.Keys(first.Trees)) {
|
||||
read := first
|
||||
if dir != "" {
|
||||
if read, err = ix.Read(ctx, repository, head, dir); err != nil {
|
||||
return f, fmt.Errorf("the seat git could not read %q of %s at %.12s: %w", dir, repository, head, err)
|
||||
}
|
||||
}
|
||||
if f.Manifests == nil {
|
||||
f.Manifests = map[string]string{}
|
||||
}
|
||||
f.Manifests[dir] = read.Manifests[dir]
|
||||
// The reader capabilities of a manifest that names templates, its templates' text too, as the forge bridge reads them
|
||||
// (ADR 0632 §2): a template the forge does not have is no need, any other failure to read one is the head's.
|
||||
if paths := manifestTemplatePaths(read.Manifests[dir]); len(paths) > 0 {
|
||||
texts := map[string]string{}
|
||||
for _, t := range paths {
|
||||
content, err := file(path.Join(dir, t))
|
||||
if err != nil {
|
||||
return f, fmt.Errorf("the seat git could not read the template %q of %q of %s at %.12s: %w", t, dir, repository, head, err)
|
||||
}
|
||||
if content != nil {
|
||||
texts[t] = string(content)
|
||||
}
|
||||
}
|
||||
if f.Needs == nil {
|
||||
f.Needs = map[string][]string{}
|
||||
}
|
||||
f.Needs[dir], _ = catalogue.ModuleNeeds([]byte(read.Manifests[dir]), texts)
|
||||
}
|
||||
if l := read.Locks[dir]; len(l) > 0 {
|
||||
if f.Locks == nil {
|
||||
f.Locks = map[string]map[string]string{}
|
||||
}
|
||||
f.Locks[dir] = l
|
||||
}
|
||||
if p := read.Packages[dir]; len(p) > 0 {
|
||||
if f.Packages == nil {
|
||||
f.Packages = map[string][]string{}
|
||||
}
|
||||
f.Packages[dir] = p
|
||||
}
|
||||
}
|
||||
// The catalogue's predefined list at the commit, as the forge bridge carries it (ADR 0565 §2).
|
||||
if trunk.SameRepository(repository, catalogueRepository) {
|
||||
raw, err := file(predefinedFile)
|
||||
if err != nil {
|
||||
return f, fmt.Errorf("the seat git could not read %s of %s at %.12s: %w", predefinedFile, repository, head, err)
|
||||
}
|
||||
if raw == nil {
|
||||
f.PredefinedRead = true
|
||||
} else {
|
||||
f.Predefined = json.RawMessage(raw)
|
||||
}
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
// The catalogue repository and its predefined list's file, whose merged message carries the list (the forge bridge's
|
||||
// CatalogRepository and PredefinedFile).
|
||||
const (
|
||||
catalogueRepository = "novox/mesh-catalog"
|
||||
predefinedFile = "predefined.json"
|
||||
)
|
||||
|
||||
// manifestTemplatePaths is the template paths a manifest names, none for one that cannot be read.
|
||||
func manifestTemplatePaths(raw string) []string {
|
||||
m, err := catalogue.Decode([]byte(raw))
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return catalogue.TemplatePaths(m)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user