21520194336

Committed 30 Jan 2026 03:00PM UTC coverage: 61.569% (-3.9%) from 65.488%

Build # 21520194336

Build Type

Pull #92

github

Committed by

web-flow

Commit Message

Merge edff5faba into e898af477

Pull Request Pull Request #92: Add controllers to schedule rendering jobs

Coverage Stats

0 of 45 new or added lines in 1 file covered. (0.0%)

46 existing lines in 3 files now uncovered.

463 of 752 relevant lines covered (61.57%)

4.4 hits per line

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

0.0

/pkg/controller/release_controller.go

// Copyright 2026 BWI GmbH and Artefact Conduit contributors
// SPDX-License-Identifier: Apache-2.0

package controller

import (
        "context"
        "slices"

        solarv1alpha1 "go.opendefense.cloud/solar/api/solar/v1alpha1"
        batchv1 "k8s.io/api/batch/v1"
        corev1 "k8s.io/api/core/v1"
        apierrors "k8s.io/apimachinery/pkg/api/errors"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/client-go/tools/record"
        ctrl "sigs.k8s.io/controller-runtime"

        "k8s.io/client-go/kubernetes"

        "sigs.k8s.io/controller-runtime/pkg/client"
)

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

// ReleaseReconciler reconciles a Release object
type ReleaseReconciler struct {
        client.Client
        ClientSet       kubernetes.Interface
        Scheme          *runtime.Scheme
        Recorder        record.EventRecorder
        RendererImage   string
        RendererCommand string
        RendererArgs    []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=batch,resources=jobs,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups="",resources=secrets,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=core,resources=events,verbs=create;patch

// Reconcile moves the current state of the cluster closer to the desired state
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)

        // 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 job and secret, then remove finalizer
        if !res.DeletionTimestamp.IsZero() {
                log.V(1).Info("Release is being deleted")
                r.Recorder.Event(res, corev1.EventTypeWarning, "Deleting", "Release is being deleted, cleaning up worker")

                // TODO: cleanup job + secret

                // 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")
                        }
                }
        }

        // 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
                }
        }

        // TODO: reconcile job/secret

        return ctrlResult, 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(&batchv1.Job{}).
                Owns(&corev1.Secret{}).
                Complete(r)
}

1	// Copyright 2026 BWI GmbH and Artefact Conduit contributors
2	// SPDX-License-Identifier: Apache-2.0
3
4	package controller
5
6	import (
7	"context"
8	"slices"
9
10	solarv1alpha1 "go.opendefense.cloud/solar/api/solar/v1alpha1"
11	batchv1 "k8s.io/api/batch/v1"
12	corev1 "k8s.io/api/core/v1"
13	apierrors "k8s.io/apimachinery/pkg/api/errors"
14	"k8s.io/apimachinery/pkg/runtime"
15	"k8s.io/client-go/tools/record"
16	ctrl "sigs.k8s.io/controller-runtime"
17
18	"k8s.io/client-go/kubernetes"
19
20	"sigs.k8s.io/controller-runtime/pkg/client"
21	)
22
23	const (
24	releaseFinalizer = "solar.opendefense.cloud/release-finalizer"
25	)
26
27	// ReleaseReconciler reconciles a Release object
28	type ReleaseReconciler struct {
29	client.Client
30	ClientSet kubernetes.Interface
31	Scheme *runtime.Scheme
32	Recorder record.EventRecorder
33	RendererImage string
34	RendererCommand string
35	RendererArgs []string
36	}
37
38	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases,verbs=get;list;watch;create;update;patch;delete
39	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases/status,verbs=get;update;patch
40	//+kubebuilder:rbac:groups=solar.opendefense.cloud,resources=releases/finalizers,verbs=update
41	//+kubebuilder:rbac:groups=batch,resources=jobs,verbs=get;list;watch;create;update;patch;delete
42	//+kubebuilder:rbac:groups="",resources=secrets,verbs=get;list;watch;create;update;patch;delete
43	//+kubebuilder:rbac:groups=core,resources=events,verbs=create;patch
44
45	// Reconcile moves the current state of the cluster closer to the desired state
NEW 46	func (r *ReleaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	×
NEW 47	log := ctrl.LoggerFrom(ctx)	×
NEW 48	ctrlResult := ctrl.Result{}	×
NEW 49		×
NEW 50	log.V(1).Info("Release is being reconciled", "req", req)	×
NEW 51		×
NEW 52	// Fetch the Release instance	×
NEW 53	res := &solarv1alpha1.Release{}	×
NEW 54	if err := r.Get(ctx, req.NamespacedName, res); err != nil {	×
NEW 55	if apierrors.IsNotFound(err) {	×
NEW 56	// Object not found, return. Created objects are automatically garbage collected.	×
NEW 57	return ctrlResult, nil	×
NEW 58	}	×
NEW 59	return ctrlResult, errLogAndWrap(log, err, "failed to get object")	×
60	}
61
62	// Handle deletion: cleanup job and secret, then remove finalizer
NEW 63	if !res.DeletionTimestamp.IsZero() {	×
NEW 64	log.V(1).Info("Release is being deleted")	×
NEW 65	r.Recorder.Event(res, corev1.EventTypeWarning, "Deleting", "Release is being deleted, cleaning up worker")	×
NEW 66		×
NEW 67	// TODO: cleanup job + secret	×
NEW 68		×
NEW 69	// Remove finalizer	×
NEW 70	if slices.Contains(res.Finalizers, releaseFinalizer) {	×
NEW 71	log.V(1).Info("Removing finalizer from resource")	×
NEW 72	res.Finalizers = slices.DeleteFunc(res.Finalizers, func(f string) bool {	×
NEW 73	return f == releaseFinalizer	×
NEW 74	})	×
NEW 75	if err := r.Update(ctx, res); err != nil {	×
NEW 76	return ctrlResult, errLogAndWrap(log, err, "failed to remove finalizer")	×
NEW 77	}	×
78	}
79	}
80
81	// Add finalizer if not present and not deleting
NEW 82	if res.DeletionTimestamp.IsZero() {	×
NEW 83	if !slices.Contains(res.Finalizers, releaseFinalizer) {	×
NEW 84	log.V(1).Info("Adding finalizer to resource")	×
NEW 85	res.Finalizers = append(res.Finalizers, releaseFinalizer)	×
NEW 86	if err := r.Update(ctx, res); err != nil {	×
NEW 87	return ctrlResult, errLogAndWrap(log, err, "failed to add finalizer")	×
NEW 88	}	×
89	// Return without requeue; the Update event will trigger reconciliation again
NEW 90	return ctrlResult, nil	×
91	}
92	}
93
94	// TODO: reconcile job/secret
95
NEW 96	return ctrlResult, nil	×
97	}
98
99	// SetupWithManager sets up the controller with the Manager.
NEW 100	func (r *ReleaseReconciler) SetupWithManager(mgr ctrl.Manager) error {	×
NEW 101	return ctrl.NewControllerManagedBy(mgr).	×
NEW 102	For(&solarv1alpha1.Release{}).	×
NEW 103	Owns(&batchv1.Job{}).	×
NEW 104	Owns(&corev1.Secret{}).	×
NEW 105	Complete(r)	×
NEW 106	}	×

opendefensecloud / solution-arsenal / 21520194336

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