0
0
package compose
import (
"fmt"
"reflect"
"sort"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
)
const (
ReasonInvalidKey = "InvalidKey"
ReasonAmbiguousKey = "AmbiguousKey"
ReasonSettingsMismatch = "SettingsMismatch"
ReasonInvalidValue = "InvalidValue"
)
type OverrideError struct {
Key string
Reason string
Message string
}
func (e *OverrideError) Error() string {
if e.Key == "" {
return "components: " + e.Message
}
return "components." + e.Key + ": " + e.Message
}
func overrideErr(key, reason, format string, args ...any) error {
return &OverrideError{Key: key, Reason: reason, Message: fmt.Sprintf(format, args...)}
}
func OverrideErrorReason(err error) string {
if typed, ok := err.(*OverrideError); ok && typed.Reason != "" {
return typed.Reason
}
return ReasonInvalidValue
}
func resolveOverrides(overrides v1alpha1.ComponentOverrides, desired []Desired) (map[string]v1alpha1.ComponentOverride, error) {
out := make(map[string]v1alpha1.ComponentOverride, len(overrides))
keys := make([]string, 0, len(overrides))
for key := range overrides {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
kind, name, explicit := strings.Cut(key, "/")
if strings.TrimSpace(key) == "" || strings.TrimSpace(kind) == "" || (explicit && strings.TrimSpace(name) == "") {
return nil, overrideErr(key, ReasonInvalidKey, "a key names a component kind or a kind and a name")
}
var matches []Desired
for _, d := range desired {
if IsExposureKind(d.Kind) || d.Kind != kind || (explicit && d.Name != name) {
continue
}
matches = append(matches, d)
}
if len(matches) == 0 {
return nil, overrideErr(key, ReasonInvalidKey, "no %s component is in this root's desired set", key)
}
if !explicit && len(matches) > 1 {
return nil, overrideErr(key, ReasonAmbiguousKey, "%s names %d components; use %s/%s", kind, len(matches), kind, matches[0].Name)
}
ov := overrides[key]
if err := settingsFor(key, matches[0].Kind, ov.Settings); err != nil {
return nil, err
}
out[ComponentKey(matches[0].Kind, matches[0].Name)] = ov
}
return out, nil
}
func settingsBlocks(settings *v1alpha1.ComponentSettings) (map[string]any, error) {
if settings == nil {
return nil, nil
}
var out map[string]any
if err := jsonCopy(settings, &out); err != nil {
return nil, err
}
return out, nil
}
func settingsFor(key, kind string, settings *v1alpha1.ComponentSettings) error {
blocks, err := settingsBlocks(settings)
if err != nil {
return overrideErr(key, ReasonInvalidValue, "the settings do not encode: %v", err)
}
want := lowerFirst(kind)
for name := range blocks {
if name != want {
return overrideErr(key, ReasonSettingsMismatch, "settings.%s does not configure a %s component", name, kind)
}
}
return nil
}
func ApplyOverrides(overrides v1alpha1.ComponentOverrides, desired []Desired) ([]Desired, error) {
resolved, err := resolveOverrides(overrides, desired)
if err != nil {
return nil, err
}
if len(resolved) == 0 {
return desired, nil
}
out := make([]Desired, len(desired))
copy(out, desired)
for i := range out {
d := &out[i]
if IsExposureKind(d.Kind) {
continue
}
ov, ok := resolved[ComponentKey(d.Kind, d.Name)]
if !ok {
continue
}
spec, err := overrideSpec(d.Kind, d.Spec, ov)
if err != nil {
return nil, err
}
d.Spec = spec
}
return out, nil
}
func overrideSpec(kind string, spec any, ov v1alpha1.ComponentOverride) (map[string]any, error) {
base, err := SpecMap(spec)
if err != nil {
return nil, err
}
out := map[string]any{}
if base != nil {
if err := jsonCopy(base, &out); err != nil {
return nil, err
}
}
if ov.Suspend != nil && *ov.Suspend {
out[suspendField(kind)] = true
}
if ov.RestartPolicy != "" {
out["restartPolicy"] = string(ov.RestartPolicy)
}
if err := setJSON(out, "limits", ov.Limits); err != nil {
return nil, err
}
if err := setJSON(out, "serviceAuth", ov.ServiceAuth); err != nil {
return nil, err
}
if err := setJSON(out, "comms", ov.Comms); err != nil {
return nil, err
}
if ov.Ingress != nil {
if err := ingressOverride(kind, out, ov.Ingress); err != nil {
return nil, err
}
}
blocks, err := settingsBlocks(ov.Settings)
if err != nil {
return nil, err
}
if block, ok := blocks[lowerFirst(kind)].(map[string]any); ok {
deepMerge(out, block)
}
return out, nil
}
func suspendField(kind string) string {
switch kind {
case ComponentKindBidder, ComponentKindRequester:
return "suspendParticipation"
}
return "suspend"
}
func OverrideComms(overrides v1alpha1.ComponentOverrides, kind, name string, base *v1alpha1.MarketComms) *v1alpha1.MarketComms {
for _, key := range []string{ComponentKey(kind, name), kind} {
if ov, ok := overrides[key]; ok && ov.Comms != nil {
return ov.Comms
}
}
return base
}
func ingressOverride(kind string, out map[string]any, ingress *v1alpha1.IngressConfig) error {
switch kind {
case ComponentKindRequester:
return setJSON(out, "ingress", ingress)
case ComponentKindPds:
if ingress.IngressRef != nil {
return setJSON(out, "ingressRef", ingress.IngressRef)
}
case ComponentKindIngressProxy:
if p := strings.TrimSpace(ingress.Provider); p != "" {
out["provider"] = p
}
if host := strings.TrimSpace(ingress.PublicHost); host != "" {
out["publicHost"] = host
out["hostnames"] = []any{IngressHostname(host)}
identity, _ := out["identity"].(map[string]any)
if identity == nil {
identity = map[string]any{}
}
identity["handle"] = IngressHostname(host)
out["identity"] = identity
}
if x := ingress.Xrpc; x != nil {
if host := strings.TrimSpace(x.IngressProxyHost); host != "" {
out["ingressProxyHost"] = host
}
if relay := strings.TrimSpace(x.RelayURL); relay != "" {
out["relayURL"] = relay
}
if err := setJSON(out, "relayRef", x.RelayRef); err != nil {
return err
}
if err := setJSON(out, "identityRef", x.IdentityRef); err != nil {
return err
}
}
return setJSON(out, "opentunnel", ingress.OpenTunnel)
}
return nil
}
func setJSON(out map[string]any, key string, value any) error {
if isNil(value) {
return nil
}
var v any
if err := jsonCopy(value, &v); err != nil {
return err
}
out[key] = v
return nil
}
func isNil(v any) bool {
if v == nil {
return true
}
rv := reflect.ValueOf(v)
return rv.Kind() == reflect.Pointer && rv.IsNil()
}
func deepMerge(dst, src map[string]any) {
for k, v := range src {
if v == nil {
continue
}
if sm, ok := v.(map[string]any); ok {
if dm, ok := dst[k].(map[string]any); ok {
deepMerge(dm, sm)
continue
}
}
dst[k] = v
}
}