111 lines
4.4 KiB
Go
111 lines
4.4 KiB
Go
package check
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
)
|
|
|
|
// BesideRef is a sibling repository a repository's tests read, placed beside the fetched tree as a plain directory (ADR
|
|
// 0484 clause 4). Ref names the pull request's head when the commit is only there.
|
|
type BesideRef struct {
|
|
Repository string `json:"repository"`
|
|
Commit string `json:"commit"`
|
|
Ref string `json:"ref,omitempty"`
|
|
}
|
|
|
|
const (
|
|
catalogueRepository = "novox/mesh-catalog"
|
|
nodeEngineRepo = "novox/mesh-host"
|
|
nodeEngineModule = "mesh-host"
|
|
controllerRepo = "novox/mesh-controller"
|
|
)
|
|
|
|
// besideRules are the repositories each core repository's tests read, as the tests state it (mesh-sdk go/internal/beside
|
|
// beside.go): the catalogue, the node-engine, the SDK, and the delivery's pinned forge dependencies (mesh-catalog
|
|
// checks/deps). Which commit of each is besideCommit's rule.
|
|
var besideRules = map[string][]string{
|
|
controllerRepo: {catalogueRepository, nodeEngineRepo, SDKRepository},
|
|
nodeEngineRepo: {catalogueRepository, SDKRepository, controllerRepo},
|
|
SDKRepository: {catalogueRepository, nodeEngineRepo},
|
|
catalogueRepository: {SDKRepository, controllerRepo},
|
|
"novox/mesh-delivery": {SDKRepository, catalogueRepository},
|
|
}
|
|
|
|
// besideFor are the siblings a pull request's tests read (ADR 0484 clause 4): the catalogue at its trunk, always, even in a
|
|
// group holding a catalogue pull request; the node-engine at the commit the mesh runs (the commit of the indexer's module
|
|
// mesh-host, its trunk head when none is known); mesh-sdk, for the controller's tests, at the commit the controller's go.mod
|
|
// pins; any other sibling at the head of the group's pull request for it when the group holds one, else at its trunk. And
|
|
// first, the change's own repository at the trunk it is merged onto, so a test comparing a shrink-only list with the
|
|
// trunk's copy reads it at $MESH_CHECK_BESIDE/<name> (issue 1887 A12, ADR 0529 §2).
|
|
func (j *Examiner) besideFor(ctx context.Context, c *Case, p Pull) ([]BesideRef, error) {
|
|
var heads map[string]string
|
|
if j.Trunks != nil {
|
|
heads = j.Trunks.Heads()
|
|
}
|
|
var out []BesideRef
|
|
if p.Trunk != "" {
|
|
out = append(out, BesideRef{Repository: p.Repository, Commit: p.Trunk})
|
|
}
|
|
for _, repo := range besideRules[p.Repository] {
|
|
switch {
|
|
case repo == catalogueRepository:
|
|
if head := heads[repo]; head != "" {
|
|
out = append(out, BesideRef{Repository: repo, Commit: head})
|
|
}
|
|
case repo == nodeEngineRepo:
|
|
commit := ""
|
|
if j.Runs != nil {
|
|
commit = j.Runs.CommitOf(nodeEngineModule)
|
|
}
|
|
if commit == "" {
|
|
commit = heads[repo]
|
|
}
|
|
if commit != "" {
|
|
out = append(out, BesideRef{Repository: repo, Commit: commit})
|
|
}
|
|
case repo == SDKRepository && p.Repository == controllerRepo && j.Forge != nil:
|
|
text, err := j.Forge.File(ctx, p.Repository, "go.mod", p.Head)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("go.mod of %s#%d cannot be read to place the mesh-sdk its tests read: %w", p.Repository, p.Number, err)
|
|
}
|
|
pin, ok := SDKPin(text)
|
|
if !ok {
|
|
return nil, fmt.Errorf("go.mod of %s#%d names no mesh-sdk commit, so the mesh-sdk its tests read cannot be placed", p.Repository, p.Number)
|
|
}
|
|
full, err := j.Forge.FullSHA(ctx, SDKRepository, pin)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("mesh-sdk %s, which %s#%d pins, cannot be found: %w", pin, p.Repository, p.Number, err)
|
|
}
|
|
out = append(out, BesideRef{Repository: repo, Commit: full})
|
|
default:
|
|
if member := c.member(repo); member != nil {
|
|
out = append(out, BesideRef{Repository: repo, Commit: member.Head, Ref: refOf(member.Number)})
|
|
} else if head := heads[repo]; head != "" {
|
|
out = append(out, BesideRef{Repository: repo, Commit: head})
|
|
} else if repo == controllerRepo && p.Repository == nodeEngineRepo {
|
|
// The node-engine's step-nine test judges the controller's own manifest and fails without it (issue 1295): a
|
|
// checker that cannot place it says so, where placing none left that test to skip.
|
|
return nil, fmt.Errorf("the trunk head of %s is not known, so the controller the tests of %s#%d read cannot be placed beside them", repo, p.Repository, p.Number)
|
|
}
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *Case) member(repository string) *Pull {
|
|
for i := range c.Pulls {
|
|
if c.Pulls[i].Repository == repository {
|
|
return &c.Pulls[i]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func refOf(number int) string {
|
|
if number <= 0 {
|
|
return ""
|
|
}
|
|
return "refs/pull/" + strconv.Itoa(number) + "/head"
|
|
}
|