58 lines
2.1 KiB
Go
58 lines
2.1 KiB
Go
package catalogue
|
|
|
|
import "slices"
|
|
|
|
// HandedByManifest is whether a module is handed to the provisioner as far as its manifest says (Rendering.Handing
|
|
// without the machine's own words, and begin's): marked moved, not a held module's stub, with a template its build
|
|
// kept or an item.
|
|
func (m Manifest) HandedByManifest() bool {
|
|
return m.Moved && m.Handed != nil && !m.Stubbed && (len(m.Handed.Templates) > 0 || len(m.Items) > 0)
|
|
}
|
|
|
|
// Keyed is whether a need is a provision of the seat mesh-provisioner: a key, an entry in its consumer's plan, and a
|
|
// wait of the consumer's want. consumerHanded is whether the composition hands the consumer to the provisioner.
|
|
func Keyed(consumerHanded bool, n Needed) bool {
|
|
if n.ByRecord || n.Module == "" || n.From == "" {
|
|
return false
|
|
}
|
|
return consumerHanded || n.AnsweredByHelper
|
|
}
|
|
|
|
// Awaited is, of what consumer requires (not optionally), each provision Keyed answers yes for, judged from manifests
|
|
// alone, as the assigner reads them: providers answers the modules providing a provision. A provision is a need when a
|
|
// provider offers it to the mesh, or one on the consumer's machine serves facts about it (Resolve: one answered on the
|
|
// machine with nothing served binds nothing). It is keyed when the consumer is handed, or every provider's offer is
|
|
// answered by the helper: where the providers disagree, which one answers is the composition's, and nothing is waited
|
|
// for that might never be keyed. Sorted, each once.
|
|
func Awaited(consumer Manifest, providers func(provision string) []Manifest) []string {
|
|
var out []string
|
|
for _, r := range consumer.Requires {
|
|
if consumer.OptionalRequires[r] || slices.Contains(out, r) {
|
|
continue
|
|
}
|
|
by := providers(r)
|
|
if len(by) == 0 {
|
|
continue
|
|
}
|
|
need, helper := false, true
|
|
for _, p := range by {
|
|
for _, o := range p.Provides {
|
|
if o.Name != r {
|
|
continue
|
|
}
|
|
if o.At() == ScopeMesh || len(p.Serves[r]) > 0 {
|
|
need = true
|
|
}
|
|
}
|
|
if !p.AnsweredByHelperFor(r) {
|
|
helper = false
|
|
}
|
|
}
|
|
if need && (consumer.HandedByManifest() || helper) {
|
|
out = append(out, r)
|
|
}
|
|
}
|
|
slices.Sort(out)
|
|
return out
|
|
}
|