23896887941

Committed 02 Apr 2026 10:51AM UTC coverage: 71.272% (-0.09%) from 71.359%

Build # 23896887941

Build Type

push

github

Committed by

web-flow

Commit Message

feat: consider profiles in hydrated target (#337)

Coverage Stats

31 of 42 new or added lines in 1 file covered. (73.81%)

8 existing lines in 2 files now uncovered.

2213 of 3105 relevant lines covered (71.27%)

23.95 hits per line

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

86.22

/pkg/controller/hydratedtarget_controller.go

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

package controller

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

        ociname "github.com/google/go-containerregistry/pkg/name"
        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/client-go/tools/events"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/builder"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/handler"

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

const (
        hydratedTargetFinalizer = "solar.opendefense.cloud/hydrated-target-finalizer"
)

// HydratedTargetReconciler reconciles a HydratedTarget object
type HydratedTargetReconciler 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
}

var ErrReleaseNotRenderedYet = errors.New("release is not rendered yet")

//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=hydratedtargets,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=hydratedtargets/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=hydratedtargets/finalizers,verbs=update
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=profiles,verbs=get;list;watch
//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases,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:
//
//        HydratedTarget created
//            ↓
//        Add finalizer
//            ↓
//        Check if already succeeded → YES → Return (no-op)
//            ↓ NO
//        Get or create RenderTask
//            ↓
//        Update status from RenderTask

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

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

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

        // Fetch the HydratedTarget instance
        res := &solarv1alpha1.HydratedTarget{}
        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("HydratedTarget is being deleted")
                r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "Deleting", "Delete", "HydratedTarget 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, hydratedTargetFinalizer) {
                        log.V(1).Info("Removing finalizer from resource")
                        res.Finalizers = slices.DeleteFunc(res.Finalizers, func(f string) bool {
                                return f == hydratedTargetFinalizer
                        })
                        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, hydratedTargetFinalizer) {
                        log.V(1).Info("Adding finalizer to resource")
                        res.Finalizers = append(res.Finalizers, hydratedTargetFinalizer)
                        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: renderTaskName(res)}, 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 {
                        if errors.Is(err, ErrReleaseNotRenderedYet) {
                                return ctrl.Result{RequeueAfter: 30 * time.Second}, 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
        return ctrlResult, nil
}

func (r *HydratedTargetReconciler) updateStatusConditionsFromRenderTask(ctx context.Context, res *solarv1alpha1.HydratedTarget, 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",
                })

                log.V(1).Info("RenderTask completed", "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 *HydratedTargetReconciler) createRenderTask(ctx context.Context, res *solarv1alpha1.HydratedTarget) 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: renderTaskName(res),
                },
                Spec: spec,
        }
        rt.Spec.OwnerName = res.Name
        rt.Spec.OwnerNamespace = res.Namespace
        rt.Spec.OwnerKind = "HydratedTarget"

        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 Reference in Status
        res.Status.RenderTaskRef = &corev1.ObjectReference{
                APIVersion: solarv1alpha1.SchemeGroupVersion.String(),
                Kind:       "RenderTask",
                Name:       rt.Name,
        }

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

        return nil
}

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

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

        return nil
}

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

        releases := map[string]*solarv1alpha1.Release{}
        for _, v := range res.Spec.Releases {
                rel := &solarv1alpha1.Release{}
                if err := r.Get(ctx, client.ObjectKey{Name: v.Name, Namespace: res.Namespace}, rel); err != nil {
                        return spec, err
                }
                releases[rel.Name] = rel
        }
        for _, v := range res.Spec.Profiles {
                prf := &solarv1alpha1.Profile{}
                if err := r.Get(ctx, client.ObjectKey{Name: v.Name, Namespace: res.Namespace}, prf); err != nil {
                        return spec, err
                }
                if _, exists := releases[prf.Spec.ReleaseRef.Name]; exists {
                        continue
                }
                rel := &solarv1alpha1.Release{}
                if err := r.Get(ctx, client.ObjectKey{Name: prf.Spec.ReleaseRef.Name, Namespace: res.Namespace}, rel); err != nil {
                        return spec, err
                }
                releases[rel.Name] = rel
        }

        isReleaseRendered := func(rel *solarv1alpha1.Release) (bool, error) {
                condFailed := apimeta.FindStatusCondition(rel.Status.Conditions, ConditionTypeTaskFailed)
                if condFailed != nil &&
                        condFailed.Status == metav1.ConditionTrue &&
                        condFailed.ObservedGeneration >= rel.Generation {
                        return false, fmt.Errorf("rendering release %s has failed", rel.Name)
                }

                condCompleted := apimeta.FindStatusCondition(rel.Status.Conditions, ConditionTypeTaskCompleted)

                return condCompleted != nil &&
                        condCompleted.Status == metav1.ConditionTrue &&
                        condCompleted.ObservedGeneration >= rel.Generation, nil
        }

        resolvedReleases := map[string]solarv1alpha1.ResourceAccess{}
        for k, v := range releases {

                if ok, err := isReleaseRendered(v); !ok {
                        if err != nil {
                                return spec, err
                        }

                        return spec, fmt.Errorf("release %s: %w", k, ErrReleaseNotRenderedYet)
                }

                if v.Status.ChartURL == "" {
                        return spec, fmt.Errorf("chartURL of release %s was empty, check the release's status", k)
                }

                ref, err := ociname.ParseReference(v.Status.ChartURL)
                if err != nil {
                        return spec, err
                }

                repo, err := url.JoinPath(ref.Context().RegistryStr(), ref.Context().RepositoryStr())
                if err != nil {
                        return spec, err
                }

                resolvedReleases[k] = solarv1alpha1.ResourceAccess{
                        Repository: strings.TrimPrefix(repo, "oci://"),
                        Tag:        ref.Identifier(),
                }
        }

        resolvedReleaseNames := make([]string, 0, len(resolvedReleases))
        for k := range resolvedReleases {
                resolvedReleaseNames = append(resolvedReleaseNames, k)
        }

        chartName := fmt.Sprintf("ht-%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.RendererConfigTypeHydratedTarget,
                HydratedTargetConfig: solarv1alpha1.HydratedTargetConfig{
                        Chart: solarv1alpha1.ChartConfig{
                                Name:        chartName,
                                Description: fmt.Sprintf("HydratedTarget of %v", resolvedReleaseNames),
                                Version:     tag,
                                AppVersion:  tag,
                        },
                        Input: solarv1alpha1.HydratedTargetInput{
                                Releases: resolvedReleases,
                                Userdata: res.Spec.Userdata,
                        },
                },
        }
        spec.Repository = repo
        spec.Tag = tag

        return spec, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *HydratedTargetReconciler) SetupWithManager(mgr ctrl.Manager) error {
        return ctrl.NewControllerManagedBy(mgr).
                For(&solarv1alpha1.HydratedTarget{}).
                Watches(&solarv1alpha1.RenderTask{},
                        handler.EnqueueRequestsFromMapFunc(mapRenderTaskToOwner("HydratedTarget")),
                        builder.WithPredicates(renderTaskStatusChangePredicate()),
                ).
                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	"errors"
9	"fmt"
10	"net/url"
11	"slices"
12	"strings"
13	"time"
14
15	ociname "github.com/google/go-containerregistry/pkg/name"
16	corev1 "k8s.io/api/core/v1"
17	apierrors "k8s.io/apimachinery/pkg/api/errors"
18	apimeta "k8s.io/apimachinery/pkg/api/meta"
19	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
20	"k8s.io/apimachinery/pkg/runtime"
21	"k8s.io/client-go/tools/events"
22	ctrl "sigs.k8s.io/controller-runtime"
23	"sigs.k8s.io/controller-runtime/pkg/builder"
24	"sigs.k8s.io/controller-runtime/pkg/client"
25	"sigs.k8s.io/controller-runtime/pkg/handler"
26
27	solarv1alpha1 "go.opendefense.cloud/solar/api/solar/v1alpha1"
28	)
29
30	const (
31	hydratedTargetFinalizer = "solar.opendefense.cloud/hydrated-target-finalizer"
32	)
33
34	// HydratedTargetReconciler reconciles a HydratedTarget object
35	type HydratedTargetReconciler struct {
36	client.Client
37	Scheme *runtime.Scheme
38	Recorder events.EventRecorder
39	// WatchNamespace restricts reconciliation to this namespace.
40	// Should be empty in production (watches all namespaces).
41	// Intended for use in integration tests only.
42	// See: https://book.kubebuilder.io/reference/envtest#testing-considerations
43	WatchNamespace string
44	}
45
46	var ErrReleaseNotRenderedYet = errors.New("release is not rendered yet")
47
48	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=hydratedtargets,verbs=get;list;watch;create;update;patch;delete
49	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=hydratedtargets/status,verbs=get;update;patch
50	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=hydratedtargets/finalizers,verbs=update
51	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=profiles,verbs=get;list;watch
52	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases,verbs=get;list;watch
53	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=rendertasks,verbs=get;list;watch;create;update;patch;delete
54	//+kubebuilder:rbac:groups=core,resources=events,verbs=create;patch
55	//+kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch
56
57	// Reconcile moves the current state of the cluster closer to the desired state
58	//
59	// Reconciliation Flow:
60	//
61	// HydratedTarget created
62	// ↓
63	// Add finalizer
64	// ↓
65	// Check if already succeeded → YES → Return (no-op)
66	// ↓ NO
67	// Get or create RenderTask
68	// ↓
69	// Update status from RenderTask
70
71	func (r *HydratedTargetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	122✔
72	log := ctrl.LoggerFrom(ctx)	122✔
73	ctrlResult := ctrl.Result{}	122✔
74		122✔
75	log.V(1).Info("HydratedTarget is being reconciled", "req", req)	122✔
76		122✔
77	if r.WatchNamespace != "" && req.Namespace != r.WatchNamespace {	138✔
78	return ctrlResult, nil	16✔
79	}	16✔
80
81	// Fetch the HydratedTarget instance
82	res := &solarv1alpha1.HydratedTarget{}	106✔
83	if err := r.Get(ctx, req.NamespacedName, res); err != nil {	108✔
84	if apierrors.IsNotFound(err) {	4✔
85	// Object not found, return. Created objects are automatically garbage collected.	2✔
86	return ctrlResult, nil	2✔
87	}	2✔
88
89	return ctrlResult, errLogAndWrap(log, err, "failed to get object")	×
90	}
91
92	// Handle deletion: cleanup rendertask, then remove finalizer
93	if !res.DeletionTimestamp.IsZero() {	107✔
94	log.V(1).Info("HydratedTarget is being deleted")	3✔
95	r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "Deleting", "Delete", "HydratedTarget is being deleted, cleaning up resources")	3✔
96		3✔
97	if err := r.deleteRenderTask(ctx, res); client.IgnoreNotFound(err) != nil {	3✔
98	return ctrlResult, errLogAndWrap(log, err, "failed to delete render task")	×
99	}	×
100
101	// Remove finalizer
102	if slices.Contains(res.Finalizers, hydratedTargetFinalizer) {	6✔
103	log.V(1).Info("Removing finalizer from resource")	3✔
104	res.Finalizers = slices.DeleteFunc(res.Finalizers, func(f string) bool {	6✔
105	return f == hydratedTargetFinalizer	3✔
106	})	3✔
107	if err := r.Update(ctx, res); err != nil {	4✔
108	return ctrlResult, errLogAndWrap(log, err, "failed to remove finalizer")	1✔
109	}	1✔
110	}
111
112	return ctrlResult, nil	2✔
113	}
114
115	// Add finalizer if not present and not deleting
116	if res.DeletionTimestamp.IsZero() {	202✔
117	if !slices.Contains(res.Finalizers, hydratedTargetFinalizer) {	120✔
118	log.V(1).Info("Adding finalizer to resource")	19✔
119	res.Finalizers = append(res.Finalizers, hydratedTargetFinalizer)	19✔
120	if err := r.Update(ctx, res); err != nil {	19✔
121	return ctrlResult, errLogAndWrap(log, err, "failed to add finalizer")	×
122	}	×
123	// Return without requeue; the Update event will trigger reconciliation again
124	return ctrlResult, nil	19✔
125	}
126	}
127
128	// Check if rendertask has already completed successfully
129	sc := apimeta.FindStatusCondition(res.Status.Conditions, ConditionTypeTaskCompleted)	82✔
130	if sc != nil && sc.ObservedGeneration >= res.Generation && sc.Status == metav1.ConditionTrue {	83✔
131	log.V(1).Info("RenderTask has already completed successfully, no further action needed")	1✔
132	return ctrlResult, nil	1✔
133	}	1✔
134
135	// Check if rendertask has already failed
136	fc := apimeta.FindStatusCondition(res.Status.Conditions, ConditionTypeTaskFailed)	81✔
137	if fc != nil && fc.ObservedGeneration >= res.Generation && fc.Status == metav1.ConditionTrue {	82✔
138	log.V(1).Info("RenderTask has already failed, no further action needed")	1✔
139	return ctrlResult, nil	1✔
140	}	1✔
141
142	// Reconcile RenderTask
143	rt := &solarv1alpha1.RenderTask{}	80✔
144	err := r.Get(ctx, client.ObjectKey{Name: renderTaskName(res)}, rt)	80✔
145	if client.IgnoreNotFound(err) != nil {	80✔
146	return ctrlResult, errLogAndWrap(log, err, "failed to get RenderTask")	×
147	}	×
148
149	if apierrors.IsNotFound(err) {	110✔
150	if err := r.createRenderTask(ctx, res); err != nil {	46✔
151	if errors.Is(err, ErrReleaseNotRenderedYet) {	16✔
NEW 152	return ctrl.Result{RequeueAfter: 30 * time.Second}, nil	×
NEW 153	}	×
154	log.V(1).Error(err, "Failed to create RenderTask")	16✔
155	r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "CreationFailed", "Create", fmt.Sprintf("failed to create RenderTask: %q", err))	16✔
156		16✔
157	if apierrors.IsNotFound(err) {	31✔
158	return ctrl.Result{RequeueAfter: 30 * time.Second}, nil	15✔
159	}	15✔
160
161	return ctrlResult, errLogAndWrap(log, err, "failed to create RenderTask")	1✔
162	}
163	log.V(1).Info("Created RenderTask", "res", res)	14✔
164	r.Recorder.Eventf(res, rt, corev1.EventTypeNormal, "Created", "Create", "RenderTask was created")	14✔
165	}
166
167	if changed := r.updateStatusConditionsFromRenderTask(ctx, res, rt); changed {	66✔
168	if err := r.Status().Update(ctx, res); err != nil {	2✔
169	return ctrlResult, errLogAndWrap(log, err, "failed to update status")	×
170	}	×
171	}
172
173	// RenderTask still running
174	return ctrlResult, nil	64✔
175	}
176
177	func (r HydratedTargetReconciler) updateStatusConditionsFromRenderTask(ctx context.Context, res solarv1alpha1.HydratedTarget, rt *solarv1alpha1.RenderTask) (changed bool) {	64✔
178	if rt == nil \|\| res == nil {	64✔
179	return false	×
180	}	×
181
182	log := ctrl.LoggerFrom(ctx)	64✔
183		64✔
184	if apimeta.IsStatusConditionTrue(rt.Status.Conditions, ConditionTypeJobFailed) {	65✔
185	changed = apimeta.SetStatusCondition(&res.Status.Conditions, metav1.Condition{	1✔
186	Type: ConditionTypeTaskFailed,	1✔
187	Status: metav1.ConditionTrue,	1✔
188	ObservedGeneration: res.Generation,	1✔
189	Reason: "TaskFailed",	1✔
190	Message: "RenderTask failed",	1✔
191	})	1✔
192		1✔
193	log.V(1).Info("RenderTask failed", "name", rt.Name)	1✔
194	r.Recorder.Eventf(res, rt, corev1.EventTypeWarning, "TaskFailed", "RunTask", "RenderTask failed")	1✔
195		1✔
196	return changed	1✔
197	}	1✔
198
199	if apimeta.IsStatusConditionTrue(rt.Status.Conditions, ConditionTypeJobSucceeded) {	64✔
200	changed = apimeta.SetStatusCondition(&res.Status.Conditions, metav1.Condition{	1✔
201	Type: ConditionTypeTaskCompleted,	1✔
202	Status: metav1.ConditionTrue,	1✔
203	ObservedGeneration: res.Generation,	1✔
204	Reason: "TaskCompleted",	1✔
205	Message: "RenderTask completed",	1✔
206	})	1✔
207		1✔
208	log.V(1).Info("RenderTask completed", "name", rt.Name)	1✔
209	r.Recorder.Eventf(res, rt, corev1.EventTypeWarning, "TaskCompleted", "RunTask", "RenderTask completed successfully")	1✔
210		1✔
211	return changed	1✔
212	}	1✔
213
214	log.V(1).Info("RenderTask has no final condtions yet", "name", rt.Name)	62✔
215		62✔
216	return false	62✔
217	}
218
219	func (r HydratedTargetReconciler) createRenderTask(ctx context.Context, res solarv1alpha1.HydratedTarget) error {	30✔
220	log := ctrl.LoggerFrom(ctx)	30✔
221		30✔
222	// Check if we need to cleanup an old task	30✔
223	if res.Status.RenderTaskRef != nil && res.Status.RenderTaskRef.Name != "" {	39✔
224	if err := r.deleteRenderTask(ctx, res); err != nil {	9✔
225	return errLogAndWrap(log, err, "failed to cleanup old task")	×
226	}	×
227	}
228
229	spec, err := r.computeRenderTaskSpec(ctx, res)	30✔
230	if err != nil {	45✔
231	return err	15✔
232	}	15✔
233	rt := &solarv1alpha1.RenderTask{	15✔
234	ObjectMeta: metav1.ObjectMeta{	15✔
235	Name: renderTaskName(res),	15✔
236	},	15✔
237	Spec: spec,	15✔
238	}	15✔
239	rt.Spec.OwnerName = res.Name	15✔
240	rt.Spec.OwnerNamespace = res.Namespace	15✔
241	rt.Spec.OwnerKind = "HydratedTarget"	15✔
242		15✔
243	if err := r.Create(ctx, rt); err != nil {	15✔
244	r.Recorder.Eventf(res, nil, corev1.EventTypeWarning, "CreationFailed", "Create", "Failed to create RenderTask", err)	×
245	return errLogAndWrap(log, err, "failed to create RenderTask")	×
246	}	×
247
248	// Set Reference in Status
249	res.Status.RenderTaskRef = &corev1.ObjectReference{	15✔
250	APIVersion: solarv1alpha1.SchemeGroupVersion.String(),	15✔
251	Kind: "RenderTask",	15✔
252	Name: rt.Name,	15✔
253	}	15✔
254		15✔
255	if err := r.Status().Update(ctx, res); err != nil {	16✔
256	return errLogAndWrap(log, err, "failed to update status")	1✔
257	}	1✔
258
259	return nil	14✔
260	}
261
262	func (r HydratedTargetReconciler) deleteRenderTask(ctx context.Context, res solarv1alpha1.HydratedTarget) error {	12✔
263	if res.Status.RenderTaskRef == nil {	13✔
264	return nil	1✔
265	}	1✔
266
267	rt := &solarv1alpha1.RenderTask{}	11✔
268	if err := r.Get(ctx, client.ObjectKey{Name: res.Status.RenderTaskRef.Name}, rt); client.IgnoreNotFound(err) != nil {	11✔
269	return err	×
270	} else if err == nil {	17✔
271	return r.Delete(ctx, rt, client.PropagationPolicy(metav1.DeletePropagationBackground))	6✔
272	}	6✔
273
274	return nil	5✔
275	}
276
277	func (r HydratedTargetReconciler) computeRenderTaskSpec(ctx context.Context, res solarv1alpha1.HydratedTarget) (solarv1alpha1.RenderTaskSpec, error) {	30✔
278	spec := solarv1alpha1.RenderTaskSpec{}	30✔
279		30✔
280	releases := map[string]*solarv1alpha1.Release{}	30✔
281	for _, v := range res.Spec.Releases {	41✔
282	rel := &solarv1alpha1.Release{}	11✔
283	if err := r.Get(ctx, client.ObjectKey{Name: v.Name, Namespace: res.Namespace}, rel); err != nil {	14✔
284	return spec, err	3✔
285	}	3✔
286	releases[rel.Name] = rel	8✔
287	}
288	for _, v := range res.Spec.Profiles {	55✔
289	prf := &solarv1alpha1.Profile{}	28✔
290	if err := r.Get(ctx, client.ObjectKey{Name: v.Name, Namespace: res.Namespace}, prf); err != nil {	28✔
NEW 291	return spec, err	×
NEW 292	}	×
293	if _, exists := releases[prf.Spec.ReleaseRef.Name]; exists {	36✔
294	continue	8✔
295	}
296	rel := &solarv1alpha1.Release{}	20✔
297	if err := r.Get(ctx, client.ObjectKey{Name: prf.Spec.ReleaseRef.Name, Namespace: res.Namespace}, rel); err != nil {	32✔
298	return spec, err	12✔
299	}	12✔
300	releases[rel.Name] = rel	8✔
301	}
302
303	isReleaseRendered := func(rel *solarv1alpha1.Release) (bool, error) {	31✔
304	condFailed := apimeta.FindStatusCondition(rel.Status.Conditions, ConditionTypeTaskFailed)	16✔
305	if condFailed != nil &&	16✔
306	condFailed.Status == metav1.ConditionTrue &&	16✔
307	condFailed.ObservedGeneration >= rel.Generation {	16✔
NEW 308	return false, fmt.Errorf("rendering release %s has failed", rel.Name)	×
NEW 309	}	×
310
311	condCompleted := apimeta.FindStatusCondition(rel.Status.Conditions, ConditionTypeTaskCompleted)	16✔
312		16✔
313	return condCompleted != nil &&	16✔
314	condCompleted.Status == metav1.ConditionTrue &&	16✔
315	condCompleted.ObservedGeneration >= rel.Generation, nil	16✔
316	}
317
318	resolvedReleases := map[string]solarv1alpha1.ResourceAccess{}	15✔
319	for k, v := range releases {	31✔
320		16✔
321	if ok, err := isReleaseRendered(v); !ok {	16✔
NEW 322	if err != nil {	×
NEW 323	return spec, err	×
NEW 324	}	×
325
NEW 326	return spec, fmt.Errorf("release %s: %w", k, ErrReleaseNotRenderedYet)	×
327	}
328
329	if v.Status.ChartURL == "" {	16✔
NEW 330	return spec, fmt.Errorf("chartURL of release %s was empty, check the release's status", k)	×
UNCOV 331	}	×
332
333	ref, err := ociname.ParseReference(v.Status.ChartURL)	16✔
334	if err != nil {	16✔
335	return spec, err	×
336	}	×
337
338	repo, err := url.JoinPath(ref.Context().RegistryStr(), ref.Context().RepositoryStr())	16✔
339	if err != nil {	16✔
340	return spec, err	×
341	}	×
342
343	resolvedReleases[k] = solarv1alpha1.ResourceAccess{	16✔
344	Repository: strings.TrimPrefix(repo, "oci://"),	16✔
345	Tag: ref.Identifier(),	16✔
346	}	16✔
347	}
348
349	resolvedReleaseNames := make([]string, 0, len(resolvedReleases))	15✔
350	for k := range resolvedReleases {	31✔
351	resolvedReleaseNames = append(resolvedReleaseNames, k)	16✔
352	}	16✔
353
354	chartName := fmt.Sprintf("ht-%s", res.Name)	15✔
355	repo, err := url.JoinPath(res.Namespace, chartName)	15✔
356	if err != nil {	15✔
357	return spec, err	×
358	}	×
359
360	tag := fmt.Sprintf("v0.0.%d", res.GetGeneration())	15✔
361		15✔
362	spec.RendererConfig = solarv1alpha1.RendererConfig{	15✔
363	Type: solarv1alpha1.RendererConfigTypeHydratedTarget,	15✔
364	HydratedTargetConfig: solarv1alpha1.HydratedTargetConfig{	15✔
365	Chart: solarv1alpha1.ChartConfig{	15✔
366	Name: chartName,	15✔
367	Description: fmt.Sprintf("HydratedTarget of %v", resolvedReleaseNames),	15✔
368	Version: tag,	15✔
369	AppVersion: tag,	15✔
370	},	15✔
371	Input: solarv1alpha1.HydratedTargetInput{	15✔
372	Releases: resolvedReleases,	15✔
373	Userdata: res.Spec.Userdata,	15✔
374	},	15✔
375	},	15✔
376	}	15✔
377	spec.Repository = repo	15✔
378	spec.Tag = tag	15✔
379		15✔
380	return spec, nil	15✔
381	}
382
383	// SetupWithManager sets up the controller with the Manager.
384	func (r *HydratedTargetReconciler) SetupWithManager(mgr ctrl.Manager) error {	1✔
385	return ctrl.NewControllerManagedBy(mgr).	1✔
386	For(&solarv1alpha1.HydratedTarget{}).	1✔
387	Watches(&solarv1alpha1.RenderTask{},	1✔
388	handler.EnqueueRequestsFromMapFunc(mapRenderTaskToOwner("HydratedTarget")),	1✔
389	builder.WithPredicates(renderTaskStatusChangePredicate()),	1✔
390	).	1✔
391	Complete(r)	1✔
392	}	1✔

opendefensecloud / solution-arsenal / 23896887941

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