0
0
package controller
import (
"bytes"
"context"
"encoding/json"
"reflect"
"sort"
"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 (
DefaultStatusTimeout = 15 * time.Second
ConditionRunning = "Running"
)
func StartingStatus(run *policyv1alpha1.PolicyWorkflowRun, now time.Time) policyv1alpha1.PolicyWorkflowRunStatus {
restarts := run.Status.Restarts
starting := *run.Status.DeepCopy()
starting.Phase = policyv1alpha1.PolicyWorkflowRunRunning
starting.Restarts = restarts
if starting.StartTime == nil {
started := metav1.NewTime(now)
starting.StartTime = &started
}
conditions := append([]metav1.Condition(nil), starting.Conditions...)
if run.Status.Phase == policyv1alpha1.PolicyWorkflowRunRunning {
restarts++
starting.Restarts = restarts
meta.SetStatusCondition(&conditions, metav1.Condition{
Type: policyengine.ConditionRestarted,
Status: metav1.ConditionTrue,
Reason: "Restarted",
Message: "the policy run is executing again",
})
}
meta.SetStatusCondition(&conditions, metav1.Condition{
Type: ConditionRunning,
Status: metav1.ConditionTrue,
Reason: "Executing",
Message: "the policy run is executing",
ObservedGeneration: run.Generation,
})
starting.Conditions = conditions
return starting
}
func FinalStatus(current *policyv1alpha1.PolicyWorkflowRun, outcome Outcome, now time.Time) policyv1alpha1.PolicyWorkflowRunStatus {
status := RunStatusFromOutcome(outcome)
status.Restarts = max(status.Restarts, current.Status.Restarts)
switch {
case current.Spec.Suspend:
suspended := RunStatusFromOutcome(cancelledOutcome(current, policyengine.ConditionSuspended, "Suspended", "the run is suspended"))
status = preserveResult(suspended, status)
case current.Spec.Cancel:
cancelled := RunStatusFromOutcome(cancelledOutcome(current, policyengine.ConditionCancelled, "Cancelled", "the run was cancelled"))
status = preserveResult(cancelled, status)
}
if status.RunID == "" {
status.RunID = current.Status.RunID
}
if status.StartTime == nil {
status.StartTime = current.Status.StartTime
}
if status.StartTime == nil {
started := metav1.NewTime(now)
status.StartTime = &started
}
if status.CompletionTime == nil {
completed := metav1.NewTime(now)
status.CompletionTime = &completed
}
if status.Phase == "" {
status.Phase = policyv1alpha1.PolicyWorkflowRunFailed
status.ExitStatus = policyv1alpha1.PolicyExitStatusFailure
}
return status
}
func CancelledStatus(run *policyv1alpha1.PolicyWorkflowRun) policyv1alpha1.PolicyWorkflowRunStatus {
return RunStatusFromOutcome(cancelledOutcome(run, policyengine.ConditionCancelled, "Cancelled", "the run was cancelled"))
}
func SuspendedStatus(run *policyv1alpha1.PolicyWorkflowRun) policyv1alpha1.PolicyWorkflowRunStatus {
return RunStatusFromOutcome(cancelledOutcome(run, policyengine.ConditionSuspended, "Suspended", "the run is suspended"))
}
func DeadlineStatus(run *policyv1alpha1.PolicyWorkflowRun) policyv1alpha1.PolicyWorkflowRunStatus {
return notStartedStatus(run, "DeadlineExceeded", "the policy run exceeded its deadline")
}
func EngineNotReadyStatus(run *policyv1alpha1.PolicyWorkflowRun, message string) policyv1alpha1.PolicyWorkflowRunStatus {
return notStartedStatus(run, "EngineNotReady", message)
}
func notStartedStatus(run *policyv1alpha1.PolicyWorkflowRun, reason, message string) policyv1alpha1.PolicyWorkflowRunStatus {
outcome := failedOutcome(nil)
outcome.Status.Annotations["error"] = []models.Annotation{{AnnotationLevel: models.AnnotationError, Message: message, Title: message}}
outcome.Status.Conditions = nil
meta.SetStatusCondition(&outcome.Status.Conditions, metav1.Condition{
Type: policyengine.ConditionFailed,
Status: metav1.ConditionTrue,
Reason: reason,
Message: message,
})
status := RunStatusFromOutcome(outcome)
status.RunID = run.Status.RunID
status.Restarts = run.Status.Restarts
status.StartTime = run.Status.StartTime
return status
}
func PendingStatus(run *policyv1alpha1.PolicyWorkflowRun, reason, message string) policyv1alpha1.PolicyWorkflowRunStatus {
value := *run.Status.DeepCopy()
value.Phase = policyv1alpha1.PolicyWorkflowRunPending
conditions := append([]metav1.Condition(nil), value.Conditions...)
meta.SetStatusCondition(&conditions, metav1.Condition{
Type: policyengine.ConditionReady,
Status: metav1.ConditionFalse,
Reason: reason,
Message: message,
ObservedGeneration: run.Generation,
})
value.Conditions = conditions
return value
}
func preserveResult(status, result policyv1alpha1.PolicyWorkflowRunStatus) policyv1alpha1.PolicyWorkflowRunStatus {
if result.RunID != "" {
status.RunID = result.RunID
}
if result.Outputs != nil {
status.Outputs = result.Outputs
}
if result.Cache != nil {
status.Cache = result.Cache
}
if result.ConsoleOutput != "" {
status.ConsoleOutput = result.ConsoleOutput
}
if result.Annotations != nil {
status.Annotations = result.Annotations
}
return status
}
func RunDeadline(run *policyv1alpha1.PolicyWorkflowRun) (time.Time, bool) {
if run.Spec.ActiveDeadlineSeconds == nil || *run.Spec.ActiveDeadlineSeconds <= 0 {
return time.Time{}, false
}
start := run.CreationTimestamp.Time
if run.Status.StartTime != nil {
start = run.Status.StartTime.Time
}
return start.Add(time.Duration(*run.Spec.ActiveDeadlineSeconds) * time.Second), true
}
func RunTTL(run *policyv1alpha1.PolicyWorkflowRun, workflow *policyv1alpha1.PolicyWorkflow, fallback time.Duration) (time.Duration, bool) {
if run.Spec.TTLSecondsAfterFinished != nil {
if *run.Spec.TTLSecondsAfterFinished < 0 {
return 0, false
}
return time.Duration(*run.Spec.TTLSecondsAfterFinished) * time.Second, true
}
if workflow != nil && workflow.Spec.TTLSecondsAfterFinished != nil {
if *workflow.Spec.TTLSecondsAfterFinished < 0 {
return 0, false
}
return time.Duration(*workflow.Spec.TTLSecondsAfterFinished) * time.Second, true
}
if fallback > 0 {
return fallback, true
}
return 0, false
}
func RunExpiry(run *policyv1alpha1.PolicyWorkflowRun, ttl time.Duration) time.Time {
completed := run.Status.CompletionTime
if completed == nil {
completed = run.Status.StartTime
}
if completed == nil {
created := run.CreationTimestamp
completed = &created
}
return completed.Add(ttl)
}
func Finished(run *policyv1alpha1.PolicyWorkflowRun) bool {
return run.Status.Phase == policyv1alpha1.PolicyWorkflowRunSucceeded || run.Status.Phase == policyv1alpha1.PolicyWorkflowRunFailed
}
func (r *TriggerReconciler) DispatchRuns(ctx context.Context, trigger *policyv1alpha1.PolicyTrigger, runs []*policyv1alpha1.PolicyWorkflowRun,
write func(TriggerReconcileState) error) error {
finished := make([]*policyv1alpha1.PolicyWorkflowRun, 0, len(runs))
for _, run := range runs {
if Finished(run) {
finished = append(finished, run)
}
}
sort.SliceStable(finished, func(i, j int) bool {
left := RunCompletion(finished[i])
right := RunCompletion(finished[j])
if left.Equal(right) {
return finished[i].Name < finished[j].Name
}
return left.Before(right)
})
var lastErr error
for _, run := range finished {
completion := metav1.NewTime(RunCompletion(run))
if !TriggerMatchesRun(trigger, run) {
continue
}
if trigger.Status.LastRun != nil && !completion.After(trigger.Status.LastRun.Time) {
continue
}
state, err := r.Handle(ctx, trigger, OutcomeFromRun(run))
if err != nil {
lastErr = err
continue
}
state.LastRun = &completion
state.NextRun = trigger.Status.NextRun
conditions := append([]metav1.Condition(nil), trigger.Status.Conditions...)
for _, condition := range state.Conditions {
meta.SetStatusCondition(&conditions, condition)
}
state.Conditions = conditions
if err := write(state); err != nil {
return err
}
trigger.Status.LastRun = state.LastRun
trigger.Status.NextRun = state.NextRun
trigger.Status.Active = state.Active
trigger.Status.Conditions = state.Conditions
}
return lastErr
}
func TriggerMatchesRun(trigger *policyv1alpha1.PolicyTrigger, run *policyv1alpha1.PolicyWorkflowRun) bool {
if trigger.DeletionTimestamp != nil || trigger.Spec.Suspend {
return false
}
if !trigger.CreationTimestamp.IsZero() && RunCompletion(run).Before(trigger.CreationTimestamp.Time) {
return false
}
if trigger.Spec.EngineRef != "" && run.Spec.EngineRef != "" && trigger.Spec.EngineRef != run.Spec.EngineRef {
return false
}
if trigger.Spec.WorkflowRef != "" {
if run.Spec.WorkflowRef != trigger.Spec.WorkflowRef {
return false
}
} else if len(bytes.TrimSpace(trigger.Spec.Workflow)) > 0 {
if len(bytes.TrimSpace(run.Spec.Workflow)) == 0 {
return false
}
left, leftErr := normalizeWorkflow(trigger.Spec.Workflow)
right, rightErr := normalizeWorkflow(run.Spec.Workflow)
if leftErr != nil || rightErr != nil || !bytes.Equal(left, right) {
return false
}
}
return MatchesOutputs(outputsFromAPI(run.Status.Outputs), trigger.Spec.Match)
}
func OutcomeFromRun(run *policyv1alpha1.PolicyWorkflowRun) Outcome {
status := policyengine.Status{
Phase: policyengine.Phase(run.Status.Phase),
RunID: run.Status.RunID,
ExitStatus: models.ExitStatus(run.Status.ExitStatus),
Outputs: outputsFromAPI(run.Status.Outputs),
Cache: CacheFromAPI(run.Status.Cache),
ConsoleOutput: run.Status.ConsoleOutput,
Annotations: annotationsFromAPI(run.Status.Annotations),
Restarts: run.Status.Restarts,
StartedAt: run.Status.StartTime,
CompletedAt: run.Status.CompletionTime,
Conditions: append([]metav1.Condition(nil), run.Status.Conditions...),
}
return Outcome{
Result: models.Result{
RunID: status.RunID,
Status: models.ExecutionComplete,
ExitStatus: status.ExitStatus,
Outputs: status.Outputs,
Cache: status.Cache,
Annotations: status.Annotations,
ConsoleOutput: status.ConsoleOutput,
},
Status: status,
}
}
func outputsFromAPI(values map[string]json.RawMessage) models.Outputs {
out := models.Outputs{}
for key, raw := range values {
var value any
if err := json.Unmarshal(raw, &value); err != nil {
continue
}
out[key] = value
}
return out
}
func annotationsFromAPI(values map[string]json.RawMessage) models.Annotations {
out := models.Annotations{}
for key, raw := range values {
var value any
if err := json.Unmarshal(raw, &value); err != nil {
continue
}
if object, ok := value.(map[string]any); ok && len(object) == 1 {
if items, exists := object["items"]; exists {
out[key] = items
continue
}
if single, exists := object["value"]; exists {
out[key] = single
continue
}
}
out[key] = value
}
return out
}
func RunCompletion(run *policyv1alpha1.PolicyWorkflowRun) time.Time {
if run.Status.CompletionTime != nil {
return run.Status.CompletionTime.Time
}
if run.Status.StartTime != nil {
return run.Status.StartTime.Time
}
return run.CreationTimestamp.Time
}
func EngineStatusEqual(current policyv1alpha1.PolicyEngineStatus, state EngineReconcileState) bool {
return current.Phase == state.Phase && current.Ready == state.Ready && current.ActiveRuns == state.ActiveRuns && conditionsMatch(current.Conditions, state.Conditions)
}
func WorkflowStatusEqual(current policyv1alpha1.PolicyWorkflowStatus, state WorkflowReconcileState, generation int64) bool {
return current.Phase == state.Phase && current.ObservedGeneration == generation && conditionsMatch(current.Conditions, state.Conditions)
}
func TriggerStatusEqual(current policyv1alpha1.PolicyTriggerStatus, state TriggerReconcileState) bool {
return timePtrEqual(current.LastRun, state.LastRun) && timePtrEqual(current.NextRun, state.NextRun) && current.Active == state.Active && conditionsMatch(current.Conditions, state.Conditions)
}
func RunStatusEqual(current, next policyv1alpha1.PolicyWorkflowRunStatus) bool {
if current.Phase != next.Phase || current.RunID != next.RunID || current.ExitStatus != next.ExitStatus || current.Restarts != next.Restarts {
return false
}
if current.ConsoleOutput != next.ConsoleOutput {
return false
}
if !timePtrEqual(current.StartTime, next.StartTime) || !timePtrEqual(current.CompletionTime, next.CompletionTime) {
return false
}
if !reflect.DeepEqual(current.Outputs, next.Outputs) || !reflect.DeepEqual(current.Cache, next.Cache) || !reflect.DeepEqual(current.Annotations, next.Annotations) {
return false
}
return conditionsMatch(current.Conditions, next.Conditions)
}
func conditionsMatch(left, right []metav1.Condition) bool {
if len(left) != len(right) {
return false
}
normalize := func(values []metav1.Condition) []metav1.Condition {
out := make([]metav1.Condition, len(values))
copy(out, values)
for index := range out {
out[index].LastTransitionTime = metav1.Time{}
}
sort.SliceStable(out, func(i, j int) bool {
return out[i].Type < out[j].Type
})
return out
}
return reflect.DeepEqual(normalize(left), normalize(right))
}
func timePtrEqual(left, right *metav1.Time) bool {
if left == nil || right == nil {
return left == nil && right == nil
}
return left.Time.Equal(right.Time)
}