0
0
package controller
import (
"bytes"
"encoding/json"
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"
)
func CacheFromAPI(value policyv1alpha1.PolicyCache) models.Cache {
if value == nil {
return models.Cache{}
}
out := make(models.Cache, len(value))
for key, entry := range value {
files := make(models.CacheEntry, len(entry))
for path, file := range entry {
encoding := models.CacheEncodingText
if file.Encoding == policyv1alpha1.PolicyCacheEncodingBase64 {
encoding = models.CacheEncodingBase64
}
files[path] = models.CacheFile{Data: file.Data, Encoding: encoding}
}
out[key] = files
}
return out
}
func CacheToAPI(value models.Cache) policyv1alpha1.PolicyCache {
if value == nil {
return nil
}
out := make(policyv1alpha1.PolicyCache, len(value))
for key, entry := range value {
files := make(policyv1alpha1.PolicyCacheEntry, len(entry))
for path, file := range entry {
encoding := policyv1alpha1.PolicyCacheEncodingText
if file.Encoding == models.CacheEncodingBase64 {
encoding = policyv1alpha1.PolicyCacheEncodingBase64
}
files[path] = policyv1alpha1.PolicyCacheFile{Data: file.Data, Encoding: encoding}
}
out[key] = files
}
return out
}
func RunStatusFromOutcome(outcome Outcome) policyv1alpha1.PolicyWorkflowRunStatus {
value := policyv1alpha1.PolicyWorkflowRunStatus{
Phase: runPhase(outcome.Status.Phase),
RunID: outcome.Status.RunID,
ExitStatus: exitStatus(outcome.Status.ExitStatus),
Cache: CacheToAPI(outcome.Status.Cache),
ConsoleOutput: outcome.Status.ConsoleOutput,
Restarts: outcome.Status.Restarts,
StartTime: outcome.Status.StartedAt,
CompletionTime: outcome.Status.CompletedAt,
Conditions: append([]metav1.Condition(nil), outcome.Status.Conditions...),
}
if len(outcome.Status.Outputs) > 0 {
value.Outputs = make(map[string]json.RawMessage, len(outcome.Status.Outputs))
for key, item := range outcome.Status.Outputs {
if data, err := json.Marshal(item); err == nil {
value.Outputs[key] = data
}
}
}
if len(outcome.Status.Annotations) > 0 {
value.Annotations = annotationsToAPI(outcome.Status.Annotations)
}
return value
}
func annotationsToAPI(value models.Annotations) map[string]json.RawMessage {
if len(value) == 0 {
return nil
}
out := make(map[string]json.RawMessage, len(value))
for key, item := range value {
data, err := json.Marshal(item)
if err != nil {
continue
}
trimmed := bytes.TrimSpace(data)
if len(trimmed) == 0 {
continue
}
switch trimmed[0] {
case '[':
wrapped, err := json.Marshal(map[string]json.RawMessage{"items": json.RawMessage(trimmed)})
if err != nil {
continue
}
out[key] = wrapped
case '{':
out[key] = append(json.RawMessage(nil), trimmed...)
default:
wrapped, err := json.Marshal(map[string]json.RawMessage{"value": json.RawMessage(trimmed)})
if err != nil {
continue
}
out[key] = wrapped
}
}
if len(out) == 0 {
return nil
}
return out
}
func runPhase(value policyengine.Phase) policyv1alpha1.PolicyWorkflowRunPhase {
switch value {
case policyengine.PhaseSucceeded:
return policyv1alpha1.PolicyWorkflowRunSucceeded
case policyengine.PhaseFailed:
return policyv1alpha1.PolicyWorkflowRunFailed
case policyengine.PhaseCancelled:
return policyv1alpha1.PolicyWorkflowRunCancelled
case policyengine.PhaseRunning:
return policyv1alpha1.PolicyWorkflowRunRunning
default:
return policyv1alpha1.PolicyWorkflowRunPending
}
}
func exitStatus(value models.ExitStatus) policyv1alpha1.PolicyExitStatus {
if value == models.ExitSuccess {
return policyv1alpha1.PolicyExitStatusSuccess
}
if value == models.ExitFailure {
return policyv1alpha1.PolicyExitStatusFailure
}
return ""
}