142 lines
4.8 KiB
Go
142 lines
4.8 KiB
Go
package controlplanestore
|
|
|
|
import (
|
|
"fmt"
|
|
"maps"
|
|
"net/url"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
)
|
|
|
|
// ForgeConnectionsKind is the resource holding an organisation's external
|
|
// forge connections. Its document is []config.ForgeConnection, the same shape
|
|
// the runtime resolves, so a stored connection and a resolved one cannot
|
|
// disagree about what a connection is.
|
|
const ForgeConnectionsKind = "forge-connections"
|
|
|
|
// rootConnectionID names the connection the file's [forge] section migrates
|
|
// into: the instance root's own account, used by root tasks.
|
|
const rootConnectionID = "default"
|
|
|
|
func forgeConnectionsDefinition() Definition {
|
|
return Definition{
|
|
Kind: ForgeConnectionsKind,
|
|
Title: "Forge connections",
|
|
ApplyMode: "live",
|
|
Document: []config.ForgeConnection{},
|
|
Seed: seedForgeConnections,
|
|
Validate: validateForgeConnections,
|
|
}
|
|
}
|
|
|
|
// seedForgeConnections migrates the file's [forge] into the root connection.
|
|
// It grants no execution identity a permit, so the migration neither widens
|
|
// nor narrows access. The file never recorded
|
|
// which external account a credential belongs to, so Account is seeded empty
|
|
// and is filled by a verification.
|
|
func seedForgeConnections(cfg config.Config) any {
|
|
out := []config.ForgeConnection{}
|
|
if c, ok := connectionFromForge(rootConnectionID, connectionDisplayName(cfg.Forge), cfg.Forge); ok {
|
|
// Root tasks act as the instance, not as an organisation execution
|
|
// identity, so they take this connection without a permit entry. An
|
|
// execution identity needs one, and the file granted it none.
|
|
out = append(out, c)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// connectionDisplayName is the label an operator sees, so it names the thing
|
|
// that tells one connection from another -- the host it points at -- rather
|
|
// than the archie concept it was migrated from. The file never named the
|
|
// forge, so there is nothing better to carry over.
|
|
func connectionDisplayName(cfg config.Forge) string {
|
|
host := strings.TrimSpace(cfg.Host)
|
|
if u, err := url.Parse(host); err == nil && u.Hostname() != "" {
|
|
host = u.Hostname()
|
|
}
|
|
if host != "" {
|
|
return host
|
|
}
|
|
return strings.TrimSpace(cfg.Type)
|
|
}
|
|
|
|
// connectionFromForge reads one file forge section as a connection. A forge
|
|
// with no type is not configured and seeds nothing.
|
|
func connectionFromForge(id, name string, cfg config.Forge) (config.ForgeConnection, bool) {
|
|
if strings.TrimSpace(cfg.Type) == "" {
|
|
return config.ForgeConnection{}, false
|
|
}
|
|
return config.ForgeConnection{
|
|
ID: id, Name: name, Type: cfg.Type, Host: cfg.Host, Token: cfg.Token,
|
|
}, true
|
|
}
|
|
|
|
// rootConnection is the connection an instance's own tasks act through: the
|
|
// one the file's [forge] section migrated into.
|
|
func rootConnection(connections []config.ForgeConnection) (config.ForgeConnection, bool) {
|
|
for _, c := range connections {
|
|
if c.ID == rootConnectionID {
|
|
return c, true
|
|
}
|
|
}
|
|
return config.ForgeConnection{}, false
|
|
}
|
|
|
|
func validateForgeConnections(input []byte) error {
|
|
return validateAs(input, func(connections []config.ForgeConnection) error {
|
|
seen := make(map[string]struct{}, len(connections))
|
|
for _, c := range connections {
|
|
if err := validateForgeConnection(c); err != nil {
|
|
return err
|
|
}
|
|
if _, dup := seen[c.ID]; dup {
|
|
return fmt.Errorf("duplicate connection %q", c.ID)
|
|
}
|
|
seen[c.ID] = struct{}{}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func validateForgeConnection(c config.ForgeConnection) error {
|
|
// A slash would let an ID spell another resource's audit record key, the
|
|
// same reason resource keys refuse one.
|
|
if strings.TrimSpace(c.ID) == "" || strings.Contains(c.ID, "/") {
|
|
return fmt.Errorf("connection ID is required and may not contain %q", "/")
|
|
}
|
|
if strings.TrimSpace(c.Name) == "" {
|
|
return fmt.Errorf("connection %q needs a name", c.ID)
|
|
}
|
|
if strings.TrimSpace(c.Type) == "" {
|
|
return fmt.Errorf("connection %q needs a forge type", c.ID)
|
|
}
|
|
if strings.TrimSpace(c.Host) == "" {
|
|
return fmt.Errorf("connection %q needs a host", c.ID)
|
|
}
|
|
if (c.Token.Engine == "") != (c.Token.Key == "") {
|
|
return fmt.Errorf("connection %q: the credential reference needs both an engine and a key", c.ID)
|
|
}
|
|
for _, id := range slices.Sorted(maps.Keys(c.Permits)) {
|
|
operations := c.Permits[id]
|
|
if strings.TrimSpace(id) == "" {
|
|
return fmt.Errorf("connection %q: a permitted identity is empty", c.ID)
|
|
}
|
|
if len(operations) == 0 {
|
|
return fmt.Errorf("connection %q: identity %s is permitted nothing; remove the entry instead", c.ID, id)
|
|
}
|
|
seen := make(map[string]struct{}, len(operations))
|
|
for _, op := range operations {
|
|
if !config.ValidOperation(op) {
|
|
return fmt.Errorf("connection %q: identity %s: unknown operation %q (want clone, push or pr)", c.ID, id, op)
|
|
}
|
|
if _, dup := seen[op]; dup {
|
|
return fmt.Errorf("connection %q: identity %s lists %q twice", c.ID, id, op)
|
|
}
|
|
seen[op] = struct{}{}
|
|
}
|
|
}
|
|
return nil
|
|
}
|