101 lines
2.7 KiB
Go
101 lines
2.7 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"sort"
|
|
)
|
|
|
|
// Chosen is the provider somebody named for a provision: the module, and the node it runs on. Both,
|
|
// always (novox/hq #258) — a provision comes from a module, and the same module on two machines is
|
|
// two answers, so neither half alone says which. Module is empty only on a record made before this
|
|
// was asked, and such a record is honoured exactly as long as it is unambiguous.
|
|
type Chosen struct {
|
|
Node string
|
|
Module string
|
|
}
|
|
|
|
func (c Chosen) String() string {
|
|
if c.Module == "" {
|
|
return c.Node
|
|
}
|
|
return c.Node + "/" + c.Module
|
|
}
|
|
|
|
// matches is whether this provider is the one chosen.
|
|
func (c Chosen) matches(p Provider) bool {
|
|
return p.Node == c.Node && (c.Module == "" || p.Module == c.Module)
|
|
}
|
|
|
|
// among is every offered provider the choice names — one, when the choice is whole.
|
|
func (c Chosen) among(where []Provider) []Provider {
|
|
var out []Provider
|
|
for _, p := range where {
|
|
if c.matches(p) {
|
|
out = append(out, p)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// nameOf is how a refusal names a provider: the node and the module on it.
|
|
func nameOf(p Provider) string {
|
|
return Chosen{Node: p.Node, Module: p.Module}.String()
|
|
}
|
|
|
|
// providerNames is every provider named, sorted, for a refusal to list.
|
|
func providerNames(where []Provider) []string {
|
|
out := make([]string, 0, len(where))
|
|
for _, p := range where {
|
|
out = append(out, nameOf(p))
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|
|
|
|
// providersHere is which modules in this node's own set offer a provision, sorted.
|
|
func providersHere(catalogue map[string]Manifest, here func(string) bool, want string) []string {
|
|
var out []string
|
|
for name, m := range catalogue {
|
|
if !here(name) {
|
|
continue
|
|
}
|
|
for _, o := range m.Offers() {
|
|
if o == want {
|
|
out = append(out, name)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|
|
|
|
// servedByOne is what one provider beside the consumer says a consumer needs to know, or nothing.
|
|
//
|
|
// Serving is *whether* a need is created at all when the provider is on this same machine (novox/hq
|
|
// 04-ISSUES/038's sibling): a need never created is a binding the consumer never gets. The manifest
|
|
// alone answers that; the values are settled later, with the node's settings.
|
|
func servedByOne(m Manifest, want string) map[string]any {
|
|
if _, ok := m.Serves[want]; ok {
|
|
return ServedOn(m, want, nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// sharedByOne is the own secret that provider names as its credential (ADR 0158), or "" when it
|
|
// gives each consumer its own.
|
|
func sharedByOne(m Manifest, want string) string {
|
|
if own, shared := m.SharedCredentialOf(want); shared {
|
|
return own
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func oneOf(list []string, s string) bool {
|
|
for _, x := range list {
|
|
if x == s {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|