0
0
package controller
import (
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"strconv"
"strings"
"sync"
"time"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
policyv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/policy/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/models"
policyengine "github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/status"
)
const TriggerActionComputeVM = "ComputeVM"
var ErrNoTriggerActionHandler = errors.New("no action handler is registered for the policy trigger action")
type ComputeVMActionHandler interface {
DispatchComputeVM(ctx context.Context, action policyv1alpha1.PolicyAction, outcome Outcome) error
}
type ComputeVMActionHandlerFunc func(ctx context.Context, action policyv1alpha1.PolicyAction, outcome Outcome) error
func (f ComputeVMActionHandlerFunc) DispatchComputeVM(ctx context.Context, action policyv1alpha1.PolicyAction, outcome Outcome) error {
return f(ctx, action, outcome)
}
type TriggerActionRegistry struct {
mu sync.RWMutex
handlers map[string]ActionHandler
}
func (r *TriggerActionRegistry) Register(handler ActionHandler) error {
if handler == nil {
return errors.New("policy trigger: action handler is required")
}
kind := strings.TrimSpace(handler.Kind())
if kind == "" {
return errors.New("policy trigger: action handler kind is required")
}
r.mu.Lock()
defer r.mu.Unlock()
if r.handlers == nil {
r.handlers = make(map[string]ActionHandler)
}
if _, exists := r.handlers[kind]; exists {
return fmt.Errorf("policy trigger: action handler for %s is already registered", kind)
}
r.handlers[kind] = handler
return nil
}
func (r *TriggerActionRegistry) RegisterComputeVM(handler ComputeVMActionHandler) error {
if handler == nil {
return errors.New("policy trigger: ComputeVM action handler is required")
}
return r.Register(computeVMActionAdapter{handler: handler})
}
func (r *TriggerActionRegistry) Lookup(kind string) (ActionHandler, bool) {
if r == nil {
return nil, false
}
r.mu.RLock()
defer r.mu.RUnlock()
handler, ok := r.handlers[strings.TrimSpace(kind)]
return handler, ok
}
func (r *TriggerActionRegistry) Dispatch(ctx context.Context, action policyv1alpha1.PolicyAction, outcome Outcome) error {
kind := strings.TrimSpace(action.Kind)
handler, ok := r.Lookup(kind)
if !ok {
return fmt.Errorf("%w: %s", ErrNoTriggerActionHandler, kind)
}
return handler.Dispatch(ctx, action.Spec, outcome)
}
func (r *TriggerActionRegistry) Handlers() map[string]ActionHandler {
if r == nil {
return nil
}
r.mu.RLock()
defer r.mu.RUnlock()
out := make(map[string]ActionHandler, len(r.handlers))
maps.Copy(out, r.handlers)
return out
}
type computeVMActionAdapter struct {
handler ComputeVMActionHandler
}
func (computeVMActionAdapter) Kind() string {
return TriggerActionComputeVM
}
func (a computeVMActionAdapter) Dispatch(ctx context.Context, spec json.RawMessage, outcome Outcome) error {
return a.handler.DispatchComputeVM(ctx, policyv1alpha1.PolicyAction{Kind: TriggerActionComputeVM, Spec: spec}, outcome)
}
type TriggerReconciler struct {
Registry *TriggerActionRegistry
Handlers map[string]ActionHandler
Now func() time.Time
}
func (r *TriggerReconciler) ReconcilePolicyTrigger(ctx context.Context, trigger *policyv1alpha1.PolicyTrigger) (TriggerReconcileState, error) {
if trigger == nil {
return TriggerReconcileState{}, fmt.Errorf("policy trigger is required")
}
if trigger.DeletionTimestamp != nil {
state := TriggerReconcileState{}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: policyengine.ConditionReady,
Status: metav1.ConditionFalse,
Reason: "Terminating",
Message: "the policy trigger is being deleted",
})
return state, nil
}
if trigger.Spec.Suspend {
state := TriggerReconcileState{}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: policyengine.ConditionSuspended,
Status: metav1.ConditionTrue,
Reason: "Suspended",
Message: "the policy trigger is suspended",
})
return state, nil
}
kind := strings.TrimSpace(trigger.Spec.Action.Kind)
if kind == "" {
return triggerInvalid("action.kind is required"), nil
}
if _, ok := r.lookup(kind); !ok {
return triggerInvalid("no action handler is registered for " + kind), nil
}
switch trigger.Spec.Source.Type {
case policyv1alpha1.PolicyTriggerSourceRecord, policyv1alpha1.PolicyTriggerSourceRelay:
case policyv1alpha1.PolicyTriggerSourceCron:
if trigger.Spec.Source.Cron == nil || strings.TrimSpace(trigger.Spec.Source.Cron.Schedule) == "" {
return triggerInvalid("source.cron.schedule is required"), nil
}
case policyv1alpha1.PolicyTriggerSourceKCP:
if trigger.Spec.Source.KCP == nil || strings.TrimSpace(trigger.Spec.Source.KCP.Resource) == "" {
return triggerInvalid("source.kcp.resource is required"), nil
}
default:
return triggerInvalid("source.type must be Record, Relay, Cron or KCP"), nil
}
state := TriggerReconcileState{}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: policyengine.ConditionReady,
Status: metav1.ConditionTrue,
Reason: "Ready",
Message: "the policy trigger is ready",
})
return state, nil
}
func (r *TriggerReconciler) Handle(ctx context.Context, trigger *policyv1alpha1.PolicyTrigger, outcome Outcome) (TriggerReconcileState, error) {
if trigger == nil {
return TriggerReconcileState{}, fmt.Errorf("policy trigger is required")
}
if trigger.Spec.Suspend {
return TriggerReconcileState{}, nil
}
kind := strings.TrimSpace(trigger.Spec.Action.Kind)
handler, ok := r.lookup(kind)
if !ok {
return triggerInvalid("no action handler is registered for " + kind), fmt.Errorf("unknown action handler %s", kind)
}
if !MatchesOutputs(outcome.Result.Outputs, trigger.Spec.Match) {
state := TriggerReconcileState{}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: "Matched",
Status: metav1.ConditionFalse,
Reason: "NoMatch",
Message: "the run outputs did not match the trigger",
})
return state, nil
}
if err := handler.Dispatch(ctx, trigger.Spec.Action.Spec, outcome); err != nil {
state := TriggerReconcileState{Active: 1}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: "Dispatched",
Status: metav1.ConditionFalse,
Reason: "DispatchFailed",
Message: err.Error(),
})
return state, err
}
now := metav1.NewTime(r.now())
state := TriggerReconcileState{LastRun: &now, Active: 1}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: "Dispatched",
Status: metav1.ConditionTrue,
Reason: "Matched",
Message: "the run outputs matched and the action was dispatched",
})
return state, nil
}
func (r *TriggerReconciler) lookup(kind string) (ActionHandler, bool) {
kind = strings.TrimSpace(kind)
if r.Registry != nil {
return r.Registry.Lookup(kind)
}
if r.Handlers == nil {
return nil, false
}
handler, ok := r.Handlers[kind]
return handler, ok
}
func (r *TriggerReconciler) now() time.Time {
if r.Now != nil {
return r.Now()
}
return time.Now()
}
func triggerInvalid(message string) TriggerReconcileState {
state := TriggerReconcileState{}
meta.SetStatusCondition(&state.Conditions, metav1.Condition{
Type: policyengine.ConditionReady,
Status: metav1.ConditionFalse,
Reason: "Invalid",
Message: message,
})
return state
}
func MatchesOutputs(outputs models.Outputs, match map[string]string) bool {
if len(match) == 0 {
return true
}
for path, expected := range match {
value, ok := lookupOutput(outputs, path)
if !ok {
return false
}
if !sameValue(value, expected) {
return false
}
}
return true
}
func lookupOutput(outputs models.Outputs, path string) (any, bool) {
var current any = map[string]any(outputs)
for part := range strings.SplitSeq(path, ".") {
switch object := current.(type) {
case map[string]any:
value, exists := object[part]
if !exists {
return nil, false
}
current = value
case map[string]string:
value, exists := object[part]
if !exists {
return nil, false
}
current = value
case models.Outputs:
value, exists := object[part]
if !exists {
return nil, false
}
current = value
default:
return nil, false
}
}
return current, true
}
func sameValue(value any, expected string) bool {
switch typed := value.(type) {
case string:
return typed == expected
case bool:
return strconv.FormatBool(typed) == expected
case nil:
return expected == "" || expected == "null"
default:
data, err := json.Marshal(typed)
if err != nil {
return fmt.Sprintf("%v", typed) == expected
}
return string(data) == expected
}
}