1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
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 ""
}
