23530208184

Committed 25 Mar 2026 07:40AM UTC coverage: 71.809% (+0.4%) from 71.419%

Build # 23530208184

Build Type

push

github

Committed by

web-flow

Commit Message

feat: add configurable TTL for failed render job cleanup (#326)

* feat: add failedJobTTL field to Release for failed job cleanup

Adds a new optional field `failedJobTTL` to ReleaseSpec that allows users
to configure how long failed render jobs are retained before cleanup.
- Field propagates from Release to RenderTask to the underlying Job's
  TTLSecondsAfterFinished
- Defaults to 3600 seconds (1 hour) if not set
- Secrets (ConfigSecret, AuthSecret) are cleaned up when RenderTask is
  deleted via the existing finalizer
- Successful jobs continue to be cleaned up immediately by the controller

* docs: More explicit documentation for new field

Coverage Stats

3 of 5 new or added lines in 2 files covered. (60.0%)

9 existing lines in 3 files now uncovered.

2183 of 3040 relevant lines covered (71.81%)

13.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.99

/pkg/controller/release_controller.go

// Copyright 2026 BWI GmbH and Solution Arsenal contributors
// SPDX-License-Identifier: Apache-2.0

package controller

import (
        "context"
        "fmt"
        "net/url"
        "slices"
        "time"

        corev1 "k8s.io/api/core/v1"
        apierrors "k8s.io/apimachinery/pkg/api/errors"
        apimeta "k8s.io/apimachinery/pkg/api/meta"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/types"
        "k8s.io/client-go/tools/events"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"

        solarv1alpha1 "go.opendefense.cloud/solar/api/solar/v1alpha1"
)

const (
        releaseFinalizer = "solar.opendefense.cloud/release-finalizer"
)

// ReleaseReconciler reconciles a Release object
type ReleaseReconciler struct {
        client.Client
        Scheme   *runtime.Scheme
        Recorder events.EventRecorder
        // WatchNamespace restricts reconciliation to this namespace.
        // Should be empty in production (watches all namespaces).
        // Intended for use in integration tests only.
        // See: https://book.kubebuilder.io/reference/envtest#testing-considerations
        WatchNamespace string
}

//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases/finalizers,verbs=update
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=componentversions,verbs=get;list;watch
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=rendertasks,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=core,resources=events,verbs=create;patch
//+kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch

// Reconcile moves the current state of the cluster closer to the desired state
//
// Reconciliation Flow:
//
//        Release created
//            ↓
//        Add finalizer
//            ↓
//        Check if already succeeded → YES → Return (no-op)
//            ↓ NO
//        Get or create RenderTask
//            ↓
//        Update status from RenderTask

func (r *ReleaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
        log := ctrl.LoggerFrom(ctx)
        ctrlResult := ctrl.Result{}

        log.V(1).Info("Release is being reconciled", "req", req)

        if r.WatchNamespace != "" && req.Namespace != r.WatchNamespace {
                return ctrlResult, nil
        }

        // Fetch the Release instance
        res := &solarv1alpha1.Release{}
        if err := r.Get(ctx, req.NamespacedName, res); err != nil {
                if apierrors.IsNotFound(err) {
                        // Object not found, return. Created objects are automatically garbage collected.
                        return ctrlResult, nil
                }

                return ctrlResult, errLogAndWrap(log, err, "failed to get object")
        }

        // Handle deletion: cleanup rendertask, then remove finalizer
        if !res.DeletionTimestamp.IsZero() {
                log.V(1).Info("Release is being deleted")
                r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "Deleting", "Delete", "Release is being deleted, cleaning up resources")

                if err := r.deleteRenderTask(ctx, res); client.IgnoreNotFound(err) != nil {
                        return ctrlResult, errLogAndWrap(log, err, "failed to delete render task")
                }

                // Remove finalizer
                if slices.Contains(res.Finalizers, releaseFinalizer) {
                        log.V(1).Info("Removing finalizer from resource")
                        res.Finalizers = slices.DeleteFunc(res.Finalizers, func(f string) bool {
                                return f == releaseFinalizer
                        })
                        if err := r.Update(ctx, res); err != nil {
                                return ctrlResult, errLogAndWrap(log, err, "failed to remove finalizer")
                        }
                }

                return ctrlResult, nil
        }

        // Add finalizer if not present and not deleting
        if res.DeletionTimestamp.IsZero() {
                if !slices.Contains(res.Finalizers, releaseFinalizer) {
                        log.V(1).Info("Adding finalizer to resource")
                        res.Finalizers = append(res.Finalizers, releaseFinalizer)
                        if err := r.Update(ctx, res); err != nil {
                                return ctrlResult, errLogAndWrap(log, err, "failed to add finalizer")
                        }
                        // Return without requeue; the Update event will trigger reconciliation again
                        return ctrlResult, nil
                }
        }

        // Check if rendertask has already completed successfully
        sc := apimeta.FindStatusCondition(res.Status.Conditions, ConditionTypeTaskCompleted)
        if sc != nil && sc.ObservedGeneration >= res.Generation && sc.Status == metav1.ConditionTrue {
                log.V(1).Info("RenderTask has already completed successfully, no further action needed")
                return ctrlResult, nil
        }

        // Check if rendertask has already failed
        fc := apimeta.FindStatusCondition(res.Status.Conditions, ConditionTypeTaskFailed)
        if fc != nil && fc.ObservedGeneration >= res.Generation && fc.Status == metav1.ConditionTrue {
                log.V(1).Info("RenderTask has already failed, no further action needed")
                return ctrlResult, nil
        }

        // Reconcile RenderTask
        rt := &solarv1alpha1.RenderTask{}
        err := r.Get(ctx, client.ObjectKey{Name: generationName(res), Namespace: res.Namespace}, rt)
        if client.IgnoreNotFound(err) != nil {
                return ctrlResult, errLogAndWrap(log, err, "failed to get RenderTask")
        }

        if apierrors.IsNotFound(err) {
                if err := r.createRenderTask(ctx, res); err != nil {
                        log.V(1).Error(err, "Failed to create RenderTask")
                        r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "CreationFailed", "Create", fmt.Sprintf("failed to create RenderTask: %q", err))

                        if apierrors.IsNotFound(err) {
                                return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
                        }

                        return ctrlResult, errLogAndWrap(log, err, "failed to create RenderTask")
                }
                log.V(1).Info("Created RenderTask", "res", res)
                r.Recorder.Eventf(res, rt, corev1.EventTypeNormal, "Created", "Create", "RenderTask was created")
        }

        if changed := r.updateStatusConditionsFromRenderTask(ctx, res, rt); changed {
                if err := r.Status().Update(ctx, res); err != nil {
                        return ctrlResult, errLogAndWrap(log, err, "failed to update status")
                }
        }

        // RenderTask still running, requeue
        return ctrl.Result{RequeueAfter: 5 * time.Second}, nil
}

func (r *ReleaseReconciler) updateStatusConditionsFromRenderTask(ctx context.Context, res *solarv1alpha1.Release, rt *solarv1alpha1.RenderTask) (changed bool) {
        if rt == nil || res == nil {
                return false
        }

        log := ctrl.LoggerFrom(ctx)

        if apimeta.IsStatusConditionTrue(rt.Status.Conditions, ConditionTypeJobFailed) {
                changed = apimeta.SetStatusCondition(&res.Status.Conditions, metav1.Condition{
                        Type:               ConditionTypeTaskFailed,
                        Status:             metav1.ConditionTrue,
                        ObservedGeneration: res.Generation,
                        Reason:             "TaskFailed",
                        Message:            "RenderTask failed",
                })

                log.V(1).Info("RenderTask failed", "name", rt.Name)
                r.Recorder.Eventf(res, rt, corev1.EventTypeWarning, "TaskFailed", "RunTask", "RenderTask failed")

                return changed
        }

        if apimeta.IsStatusConditionTrue(rt.Status.Conditions, ConditionTypeJobSucceeded) {
                changed = apimeta.SetStatusCondition(&res.Status.Conditions, metav1.Condition{
                        Type:               ConditionTypeTaskCompleted,
                        Status:             metav1.ConditionTrue,
                        ObservedGeneration: res.Generation,
                        Reason:             "TaskCompleted",
                        Message:            "RenderTask completed",
                })

                if res.Status.ChartURL != rt.Status.ChartURL {
                        res.Status.ChartURL = rt.Status.ChartURL
                        changed = true
                }

                log.V(1).Info("RenderTask succeeded", "name", rt.Name)
                r.Recorder.Eventf(res, rt, corev1.EventTypeWarning, "TaskCompleted", "RunTask", "RenderTask completed successfully")

                return changed
        }

        log.V(1).Info("RenderTask has no final condtions yet", "name", rt.Name)

        return false
}

func (r *ReleaseReconciler) createRenderTask(ctx context.Context, res *solarv1alpha1.Release) error {
        log := ctrl.LoggerFrom(ctx)

        // Check if we need to cleanup an old task
        if res.Status.RenderTaskRef != nil && res.Status.RenderTaskRef.Name != "" {
                if err := r.deleteRenderTask(ctx, res); err != nil {
                        return errLogAndWrap(log, err, "failed to cleanup old task")
                }
        }

        spec, err := r.computeRenderTaskSpec(ctx, res)
        if err != nil {
                return err
        }
        rt := &solarv1alpha1.RenderTask{
                ObjectMeta: metav1.ObjectMeta{
                        Name:      generationName(res),
                        Namespace: res.Namespace,
                },
                Spec: spec,
        }

        if err := r.Create(ctx, rt); err != nil {
                r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "CreationFailed", "Create", "Failed to create RenderTask", err)
                return errLogAndWrap(log, err, "failed to create RenderTask")
        }

        // Set owner references
        if err := controllerutil.SetControllerReference(res, rt, r.Scheme); err != nil {
                return errLogAndWrap(log, err, "failed to set controller reference")
        }

        // Set Reference in Status
        res.Status.RenderTaskRef = &corev1.ObjectReference{
                APIVersion: solarv1alpha1.SchemeGroupVersion.String(),
                Kind:       "RenderTask",
                Namespace:  rt.Namespace,
                Name:       rt.Name,
        }

        if err := r.Status().Update(ctx, res); err != nil {
                return errLogAndWrap(log, err, "failed to update status")
        }

        return nil
}

func (r *ReleaseReconciler) deleteRenderTask(ctx context.Context, res *solarv1alpha1.Release) error {
        if res.Status.RenderTaskRef == nil {
                return nil
        }

        rt := &solarv1alpha1.RenderTask{}
        if err := r.Get(ctx, client.ObjectKey{Name: res.Status.RenderTaskRef.Name, Namespace: res.Status.RenderTaskRef.Namespace}, rt); client.IgnoreNotFound(err) != nil {
                return err
        } else if err == nil {
                return r.Delete(ctx, rt, client.PropagationPolicy(metav1.DeletePropagationBackground))
        }

        return nil
}

func (r *ReleaseReconciler) computeRenderTaskSpec(ctx context.Context, res *solarv1alpha1.Release) (solarv1alpha1.RenderTaskSpec, error) {
        spec := solarv1alpha1.RenderTaskSpec{}

        cvRef := types.NamespacedName{
                Name:      res.Spec.ComponentVersionRef.Name,
                Namespace: res.Namespace,
        }

        cv := &solarv1alpha1.ComponentVersion{}
        if err := r.Get(ctx, cvRef, cv); err != nil {
                return spec, err
        }

        chartName := fmt.Sprintf("release-%s", res.Name)
        repo, err := url.JoinPath(res.Namespace, chartName)
        if err != nil {
                return spec, err
        }

        tag := fmt.Sprintf("v0.0.%d", res.GetGeneration())

        spec.RendererConfig = solarv1alpha1.RendererConfig{
                Type: solarv1alpha1.RendererConfigTypeRelease,
                ReleaseConfig: solarv1alpha1.ReleaseConfig{
                        Chart: solarv1alpha1.ChartConfig{
                                Name:        chartName,
                                Description: fmt.Sprintf("Release of %s", res.Spec.ComponentVersionRef.Name),
                                Version:     tag,
                                AppVersion:  tag,
                        },
                        Input: solarv1alpha1.ReleaseInput{
                                Component:  solarv1alpha1.ReleaseComponent{Name: cv.Spec.ComponentRef.Name},
                                Resources:  cv.Spec.Resources,
                                Entrypoint: cv.Spec.Entrypoint,
                        },
                        Values: res.Spec.Values,
                },
        }
        spec.Repository = repo
        spec.Tag = tag
        spec.FailedJobTTL = res.Spec.FailedJobTTL

        return spec, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *ReleaseReconciler) SetupWithManager(mgr ctrl.Manager) error {
        return ctrl.NewControllerManagedBy(mgr).
                For(&solarv1alpha1.Release{}).
                Owns(&solarv1alpha1.RenderTask{}).
                Complete(r)
}

1	// Copyright 2026 BWI GmbH and Solution Arsenal contributors
2	// SPDX-License-Identifier: Apache-2.0
3
4	package controller
5
6	import (
7	"context"
8	"fmt"
9	"net/url"
10	"slices"
11	"time"
12
13	corev1 "k8s.io/api/core/v1"
14	apierrors "k8s.io/apimachinery/pkg/api/errors"
15	apimeta "k8s.io/apimachinery/pkg/api/meta"
16	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
17	"k8s.io/apimachinery/pkg/runtime"
18	"k8s.io/apimachinery/pkg/types"
19	"k8s.io/client-go/tools/events"
20	ctrl "sigs.k8s.io/controller-runtime"
21	"sigs.k8s.io/controller-runtime/pkg/client"
22	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
23
24	solarv1alpha1 "go.opendefense.cloud/solar/api/solar/v1alpha1"
25	)
26
27	const (
28	releaseFinalizer = "solar.opendefense.cloud/release-finalizer"
29	)
30
31	// ReleaseReconciler reconciles a Release object
32	type ReleaseReconciler struct {
33	client.Client
34	Scheme *runtime.Scheme
35	Recorder events.EventRecorder
36	// WatchNamespace restricts reconciliation to this namespace.
37	// Should be empty in production (watches all namespaces).
38	// Intended for use in integration tests only.
39	// See: https://book.kubebuilder.io/reference/envtest#testing-considerations
40	WatchNamespace string
41	}
42
43	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases,verbs=get;list;watch;create;update;patch;delete
44	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases/status,verbs=get;update;patch
45	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases/finalizers,verbs=update
46	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=componentversions,verbs=get;list;watch
47	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=rendertasks,verbs=get;list;watch;create;update;patch;delete
48	//+kubebuilder:rbac:groups=core,resources=events,verbs=create;patch
49	//+kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch
50
51	// Reconcile moves the current state of the cluster closer to the desired state
52	//
53	// Reconciliation Flow:
54	//
55	// Release created
56	// ↓
57	// Add finalizer
58	// ↓
59	// Check if already succeeded → YES → Return (no-op)
60	// ↓ NO
61	// Get or create RenderTask
62	// ↓
63	// Update status from RenderTask
64
65	func (r *ReleaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	49✔
66	log := ctrl.LoggerFrom(ctx)	49✔
67	ctrlResult := ctrl.Result{}	49✔
68		49✔
69	log.V(1).Info("Release is being reconciled", "req", req)	49✔
70		49✔
71	if r.WatchNamespace != "" && req.Namespace != r.WatchNamespace {	55✔
72	return ctrlResult, nil	6✔
73	}	6✔
74
75	// Fetch the Release instance
76	res := &solarv1alpha1.Release{}	43✔
77	if err := r.Get(ctx, req.NamespacedName, res); err != nil {	44✔
78	if apierrors.IsNotFound(err) {	2✔
79	// Object not found, return. Created objects are automatically garbage collected.	1✔
80	return ctrlResult, nil	1✔
81	}	1✔
82
83	return ctrlResult, errLogAndWrap(log, err, "failed to get object")	×
84	}
85
86	// Handle deletion: cleanup rendertask, then remove finalizer
87	if !res.DeletionTimestamp.IsZero() {	43✔
88	log.V(1).Info("Release is being deleted")	1✔
89	r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "Deleting", "Delete", "Release is being deleted, cleaning up resources")	1✔
90		1✔
91	if err := r.deleteRenderTask(ctx, res); client.IgnoreNotFound(err) != nil {	1✔
92	return ctrlResult, errLogAndWrap(log, err, "failed to delete render task")	×
93	}	×
94
95	// Remove finalizer
96	if slices.Contains(res.Finalizers, releaseFinalizer) {	2✔
97	log.V(1).Info("Removing finalizer from resource")	1✔
98	res.Finalizers = slices.DeleteFunc(res.Finalizers, func(f string) bool {	2✔
99	return f == releaseFinalizer	1✔
100	})	1✔
101	if err := r.Update(ctx, res); err != nil {	1✔
102	return ctrlResult, errLogAndWrap(log, err, "failed to remove finalizer")	×
103	}	×
104	}
105
106	return ctrlResult, nil	1✔
107	}
108
109	// Add finalizer if not present and not deleting
110	if res.DeletionTimestamp.IsZero() {	82✔
111	if !slices.Contains(res.Finalizers, releaseFinalizer) {	55✔
112	log.V(1).Info("Adding finalizer to resource")	14✔
113	res.Finalizers = append(res.Finalizers, releaseFinalizer)	14✔
114	if err := r.Update(ctx, res); err != nil {	14✔
115	return ctrlResult, errLogAndWrap(log, err, "failed to add finalizer")	×
116	}	×
117	// Return without requeue; the Update event will trigger reconciliation again
118	return ctrlResult, nil	14✔
119	}
120	}
121
122	// Check if rendertask has already completed successfully
123	sc := apimeta.FindStatusCondition(res.Status.Conditions, ConditionTypeTaskCompleted)	27✔
124	if sc != nil && sc.ObservedGeneration >= res.Generation && sc.Status == metav1.ConditionTrue {	28✔
125	log.V(1).Info("RenderTask has already completed successfully, no further action needed")	1✔
126	return ctrlResult, nil	1✔
127	}	1✔
128
129	// Check if rendertask has already failed
130	fc := apimeta.FindStatusCondition(res.Status.Conditions, ConditionTypeTaskFailed)	26✔
131	if fc != nil && fc.ObservedGeneration >= res.Generation && fc.Status == metav1.ConditionTrue {	27✔
132	log.V(1).Info("RenderTask has already failed, no further action needed")	1✔
133	return ctrlResult, nil	1✔
134	}	1✔
135
136	// Reconcile RenderTask
137	rt := &solarv1alpha1.RenderTask{}	25✔
138	err := r.Get(ctx, client.ObjectKey{Name: generationName(res), Namespace: res.Namespace}, rt)	25✔
139	if client.IgnoreNotFound(err) != nil {	25✔
140	return ctrlResult, errLogAndWrap(log, err, "failed to get RenderTask")	×
141	}	×
142
143	if apierrors.IsNotFound(err) {	41✔
144	if err := r.createRenderTask(ctx, res); err != nil {	24✔
145	log.V(1).Error(err, "Failed to create RenderTask")	8✔
146	r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "CreationFailed", "Create", fmt.Sprintf("failed to create RenderTask: %q", err))	8✔
147		8✔
148	if apierrors.IsNotFound(err) {	15✔
149	return ctrl.Result{RequeueAfter: 30 * time.Second}, nil	7✔
150	}	7✔
151
152	return ctrlResult, errLogAndWrap(log, err, "failed to create RenderTask")	1✔
153	}
154	log.V(1).Info("Created RenderTask", "res", res)	8✔
155	r.Recorder.Eventf(res, rt, corev1.EventTypeNormal, "Created", "Create", "RenderTask was created")	8✔
156	}
157
158	if changed := r.updateStatusConditionsFromRenderTask(ctx, res, rt); changed {	19✔
159	if err := r.Status().Update(ctx, res); err != nil {	2✔
160	return ctrlResult, errLogAndWrap(log, err, "failed to update status")	×
161	}	×
162	}
163
164	// RenderTask still running, requeue
165	return ctrl.Result{RequeueAfter: 5 * time.Second}, nil	17✔
166	}
167
168	func (r ReleaseReconciler) updateStatusConditionsFromRenderTask(ctx context.Context, res solarv1alpha1.Release, rt *solarv1alpha1.RenderTask) (changed bool) {	17✔
169	if rt == nil \|\| res == nil {	17✔
170	return false	×
171	}	×
172
173	log := ctrl.LoggerFrom(ctx)	17✔
174		17✔
175	if apimeta.IsStatusConditionTrue(rt.Status.Conditions, ConditionTypeJobFailed) {	18✔
176	changed = apimeta.SetStatusCondition(&res.Status.Conditions, metav1.Condition{	1✔
177	Type: ConditionTypeTaskFailed,	1✔
178	Status: metav1.ConditionTrue,	1✔
179	ObservedGeneration: res.Generation,	1✔
180	Reason: "TaskFailed",	1✔
181	Message: "RenderTask failed",	1✔
182	})	1✔
183		1✔
184	log.V(1).Info("RenderTask failed", "name", rt.Name)	1✔
185	r.Recorder.Eventf(res, rt, corev1.EventTypeWarning, "TaskFailed", "RunTask", "RenderTask failed")	1✔
186		1✔
187	return changed	1✔
188	}	1✔
189
190	if apimeta.IsStatusConditionTrue(rt.Status.Conditions, ConditionTypeJobSucceeded) {	17✔
191	changed = apimeta.SetStatusCondition(&res.Status.Conditions, metav1.Condition{	1✔
192	Type: ConditionTypeTaskCompleted,	1✔
193	Status: metav1.ConditionTrue,	1✔
194	ObservedGeneration: res.Generation,	1✔
195	Reason: "TaskCompleted",	1✔
196	Message: "RenderTask completed",	1✔
197	})	1✔
198		1✔
199	if res.Status.ChartURL != rt.Status.ChartURL {	1✔
200	res.Status.ChartURL = rt.Status.ChartURL	×
201	changed = true	×
202	}	×
203
204	log.V(1).Info("RenderTask succeeded", "name", rt.Name)	1✔
205	r.Recorder.Eventf(res, rt, corev1.EventTypeWarning, "TaskCompleted", "RunTask", "RenderTask completed successfully")	1✔
206		1✔
207	return changed	1✔
208	}
209
210	log.V(1).Info("RenderTask has no final condtions yet", "name", rt.Name)	15✔
211		15✔
212	return false	15✔
213	}
214
215	func (r ReleaseReconciler) createRenderTask(ctx context.Context, res solarv1alpha1.Release) error {	16✔
216	log := ctrl.LoggerFrom(ctx)	16✔
217		16✔
218	// Check if we need to cleanup an old task	16✔
219	if res.Status.RenderTaskRef != nil && res.Status.RenderTaskRef.Name != "" {	17✔
220	if err := r.deleteRenderTask(ctx, res); err != nil {	1✔
221	return errLogAndWrap(log, err, "failed to cleanup old task")	×
222	}	×
223	}
224
225	spec, err := r.computeRenderTaskSpec(ctx, res)	16✔
226	if err != nil {	23✔
227	return err	7✔
228	}	7✔
229	rt := &solarv1alpha1.RenderTask{	9✔
230	ObjectMeta: metav1.ObjectMeta{	9✔
231	Name: generationName(res),	9✔
232	Namespace: res.Namespace,	9✔
233	},	9✔
234	Spec: spec,	9✔
235	}	9✔
236		9✔
237	if err := r.Create(ctx, rt); err != nil {	9✔
UNCOV 238	r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "CreationFailed", "Create", "Failed to create RenderTask", err)	×
UNCOV 239	return errLogAndWrap(log, err, "failed to create RenderTask")	×
UNCOV 240	}	×
241
242	// Set owner references
243	if err := controllerutil.SetControllerReference(res, rt, r.Scheme); err != nil {	9✔
244	return errLogAndWrap(log, err, "failed to set controller reference")	×
245	}	×
246
247	// Set Reference in Status
248	res.Status.RenderTaskRef = &corev1.ObjectReference{	9✔
249	APIVersion: solarv1alpha1.SchemeGroupVersion.String(),	9✔
250	Kind: "RenderTask",	9✔
251	Namespace: rt.Namespace,	9✔
252	Name: rt.Name,	9✔
253	}	9✔
254		9✔
255	if err := r.Status().Update(ctx, res); err != nil {	10✔
256	return errLogAndWrap(log, err, "failed to update status")	1✔
257	}	1✔
258
259	return nil	8✔
260	}
261
262	func (r ReleaseReconciler) deleteRenderTask(ctx context.Context, res solarv1alpha1.Release) error {	2✔
263	if res.Status.RenderTaskRef == nil {	2✔
264	return nil	×
265	}	×
266
267	rt := &solarv1alpha1.RenderTask{}	2✔
268	if err := r.Get(ctx, client.ObjectKey{Name: res.Status.RenderTaskRef.Name, Namespace: res.Status.RenderTaskRef.Namespace}, rt); client.IgnoreNotFound(err) != nil {	2✔
269	return err	×
270	} else if err == nil {	4✔
271	return r.Delete(ctx, rt, client.PropagationPolicy(metav1.DeletePropagationBackground))	2✔
272	}	2✔
273
274	return nil	×
275	}
276
277	func (r ReleaseReconciler) computeRenderTaskSpec(ctx context.Context, res solarv1alpha1.Release) (solarv1alpha1.RenderTaskSpec, error) {	16✔
278	spec := solarv1alpha1.RenderTaskSpec{}	16✔
279		16✔
280	cvRef := types.NamespacedName{	16✔
281	Name: res.Spec.ComponentVersionRef.Name,	16✔
282	Namespace: res.Namespace,	16✔
283	}	16✔
284		16✔
285	cv := &solarv1alpha1.ComponentVersion{}	16✔
286	if err := r.Get(ctx, cvRef, cv); err != nil {	23✔
287	return spec, err	7✔
288	}	7✔
289
290	chartName := fmt.Sprintf("release-%s", res.Name)	9✔
291	repo, err := url.JoinPath(res.Namespace, chartName)	9✔
292	if err != nil {	9✔
293	return spec, err	×
294	}	×
295
296	tag := fmt.Sprintf("v0.0.%d", res.GetGeneration())	9✔
297		9✔
298	spec.RendererConfig = solarv1alpha1.RendererConfig{	9✔
299	Type: solarv1alpha1.RendererConfigTypeRelease,	9✔
300	ReleaseConfig: solarv1alpha1.ReleaseConfig{	9✔
301	Chart: solarv1alpha1.ChartConfig{	9✔
302	Name: chartName,	9✔
303	Description: fmt.Sprintf("Release of %s", res.Spec.ComponentVersionRef.Name),	9✔
304	Version: tag,	9✔
305	AppVersion: tag,	9✔
306	},	9✔
307	Input: solarv1alpha1.ReleaseInput{	9✔
308	Component: solarv1alpha1.ReleaseComponent{Name: cv.Spec.ComponentRef.Name},	9✔
309	Resources: cv.Spec.Resources,	9✔
310	Entrypoint: cv.Spec.Entrypoint,	9✔
311	},	9✔
312	Values: res.Spec.Values,	9✔
313	},	9✔
314	}	9✔
315	spec.Repository = repo	9✔
316	spec.Tag = tag	9✔
317	spec.FailedJobTTL = res.Spec.FailedJobTTL	9✔
318		9✔
319	return spec, nil	9✔
320	}
321
322	// SetupWithManager sets up the controller with the Manager.
323	func (r *ReleaseReconciler) SetupWithManager(mgr ctrl.Manager) error {	1✔
324	return ctrl.NewControllerManagedBy(mgr).	1✔
325	For(&solarv1alpha1.Release{}).	1✔
326	Owns(&solarv1alpha1.RenderTask{}).	1✔
327	Complete(r)	1✔
328	}	1✔

opendefensecloud / solution-arsenal / 23530208184

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous