24822429227

Committed 23 Apr 2026 07:21AM UTC coverage: 72.505% (-0.5%) from 73.044%

Build # 24822429227

Build Type

Pull #436

github

Committed by

web-flow

Commit Message

Merge 4275ff704 into 7e082458b

Pull Request Pull Request #436: Registry credentials PoC

Coverage Stats

190 of 212 new or added lines in 6 files covered. (89.62%)

41 existing lines in 2 files now uncovered.

2165 of 2986 relevant lines covered (72.51%)

34.18 hits per line

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

72.45

/pkg/controller/helpers.go

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

package controller

import (
        "context"
        "crypto/sha256"
        "encoding/hex"
        "fmt"

        "k8s.io/apimachinery/pkg/types"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/handler"
        "sigs.k8s.io/controller-runtime/pkg/reconcile"

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

const (
        // Field index keys for looking up RenderTasks by owner.
        indexOwnerKind      = "spec.ownerKind"
        indexOwnerName      = "spec.ownerName"
        indexOwnerNamespace = "spec.ownerNamespace"

        // Field index keys for looking up ReleaseBindings by target or release name.
        indexReleaseBindingTargetName  = "spec.targetRef.name"
        indexReleaseBindingReleaseName = "spec.releaseRef.name"

        // Field index key for looking up RegistryBindings by target name.
        indexRegistryBindingTargetName = "spec.registryBinding.targetRef.name"

        maxK8sObjectNameLen = 253
        maxK8sLabelValueLen = 63
)

// truncateName truncates a name to maxLen characters. If truncation is needed,
// it appends a short hash suffix to preserve uniqueness.
func truncateName(name string, maxLen int) string {
        if maxLen < 10 {
                maxLen = 10
        }
        if len(name) <= maxLen {
                return name
        }
        hash := sha256.Sum256([]byte(name))
        hashStr := hex.EncodeToString(hash[:])[:8]

        return name[:maxLen-9] + "-" + hashStr
}

// mapRenderTaskToOwner returns a handler.MapFunc that maps RenderTask events
// to reconcile requests for the owning resource of the specified kind.
func mapRenderTaskToOwner(kind string) handler.MapFunc {
        return func(_ context.Context, obj client.Object) []reconcile.Request {
                rt, ok := obj.(*solarv1alpha1.RenderTask)
                if !ok {
                        return nil
                }

                if rt.Spec.OwnerKind != kind || rt.Spec.OwnerName == "" || rt.Spec.OwnerNamespace == "" {
                        return nil
                }

                return []reconcile.Request{
                        {
                                NamespacedName: types.NamespacedName{
                                        Name:      rt.Spec.OwnerName,
                                        Namespace: rt.Spec.OwnerNamespace,
                                },
                        },
                }
        }
}

// releaseRenderTaskName returns a deterministic name for a per-release RenderTask
// scoped to a specific target. Each target creates its own release RenderTasks;
// the renderer job handles deduplication by skipping rendering if the chart
// already exists in the registry.
func releaseRenderTaskName(releaseName, targetName string, generation int64) string {
        input := fmt.Sprintf("%s-%s-%d", releaseName, targetName, generation)
        hash := sha256.Sum256([]byte(input))
        hashStr := hex.EncodeToString(hash[:])[:8]

        return truncateName(fmt.Sprintf("render-rel-%s-%s", releaseName, hashStr), maxK8sObjectNameLen)
}

// targetRenderTaskName returns a deterministic name for a per-target bootstrap RenderTask.
// The bootstrapVersion is incremented each time the bootstrap needs re-rendering.
func targetRenderTaskName(targetName string, bootstrapVersion int64) string {
        return truncateName(fmt.Sprintf("render-tgt-%s-%d", targetName, bootstrapVersion), maxK8sObjectNameLen)
}

// IndexFields registers field indexers on the manager for efficient lookups.
// Must be called once before any controller that uses these indexes is set up.
func IndexFields(ctx context.Context, mgr ctrl.Manager) error {
        if err := indexReleaseBindingFields(ctx, mgr); err != nil {
                return err
        }

        if err := indexRegistryBindingFields(ctx, mgr); err != nil {
                return err
        }

        return indexRenderTaskOwnerFields(ctx, mgr)
}

func indexReleaseBindingFields(ctx context.Context, mgr ctrl.Manager) error {
        indexer := mgr.GetFieldIndexer()

        if err := indexer.IndexField(ctx, &solarv1alpha1.ReleaseBinding{}, indexReleaseBindingTargetName, func(obj client.Object) []string {
                rb := obj.(*solarv1alpha1.ReleaseBinding)
                if rb.Spec.TargetRef.Name == "" {
                        return nil
                }

                return []string{rb.Spec.TargetRef.Name}
        }); err != nil {
                return err
        }

        return indexer.IndexField(ctx, &solarv1alpha1.ReleaseBinding{}, indexReleaseBindingReleaseName, func(obj client.Object) []string {
                rb := obj.(*solarv1alpha1.ReleaseBinding)
                if rb.Spec.ReleaseRef.Name == "" {
                        return nil
                }

                return []string{rb.Spec.ReleaseRef.Name}
        })
}

func indexRegistryBindingFields(ctx context.Context, mgr ctrl.Manager) error {
        return mgr.GetFieldIndexer().IndexField(ctx, &solarv1alpha1.RegistryBinding{}, indexRegistryBindingTargetName, func(obj client.Object) []string {
                rb := obj.(*solarv1alpha1.RegistryBinding)
                if rb.Spec.TargetRef.Name == "" {
                        return nil
                }

                return []string{rb.Spec.TargetRef.Name}
        })
}

// indexRenderTaskOwnerFields registers field indexers on the manager for
// looking up RenderTasks by owner kind, name, and namespace.
func indexRenderTaskOwnerFields(ctx context.Context, mgr ctrl.Manager) error {
        indexer := mgr.GetFieldIndexer()

        if err := indexer.IndexField(ctx, &solarv1alpha1.RenderTask{}, indexOwnerKind, func(obj client.Object) []string {
                rt := obj.(*solarv1alpha1.RenderTask)
                if rt.Spec.OwnerKind == "" {
                        return nil
                }

                return []string{rt.Spec.OwnerKind}
        }); err != nil {
                return err
        }

        if err := indexer.IndexField(ctx, &solarv1alpha1.RenderTask{}, indexOwnerName, func(obj client.Object) []string {
                rt := obj.(*solarv1alpha1.RenderTask)
                if rt.Spec.OwnerName == "" {
                        return nil
                }

                return []string{rt.Spec.OwnerName}
        }); err != nil {
                return err
        }

        return indexer.IndexField(ctx, &solarv1alpha1.RenderTask{}, indexOwnerNamespace, func(obj client.Object) []string {
                rt := obj.(*solarv1alpha1.RenderTask)
                if rt.Spec.OwnerNamespace == "" {
                        return nil
                }

                return []string{rt.Spec.OwnerNamespace}
        })
}

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	"crypto/sha256"
9	"encoding/hex"
10	"fmt"
11
12	"k8s.io/apimachinery/pkg/types"
13	ctrl "sigs.k8s.io/controller-runtime"
14	"sigs.k8s.io/controller-runtime/pkg/client"
15	"sigs.k8s.io/controller-runtime/pkg/handler"
16	"sigs.k8s.io/controller-runtime/pkg/reconcile"
17
18	solarv1alpha1 "go.opendefense.cloud/solar/api/solar/v1alpha1"
19	)
20
21	const (
22	// Field index keys for looking up RenderTasks by owner.
23	indexOwnerKind = "spec.ownerKind"
24	indexOwnerName = "spec.ownerName"
25	indexOwnerNamespace = "spec.ownerNamespace"
26
27	// Field index keys for looking up ReleaseBindings by target or release name.
28	indexReleaseBindingTargetName = "spec.targetRef.name"
29	indexReleaseBindingReleaseName = "spec.releaseRef.name"
30
31	// Field index key for looking up RegistryBindings by target name.
32	indexRegistryBindingTargetName = "spec.registryBinding.targetRef.name"
33
34	maxK8sObjectNameLen = 253
35	maxK8sLabelValueLen = 63
36	)
37
38	// truncateName truncates a name to maxLen characters. If truncation is needed,
39	// it appends a short hash suffix to preserve uniqueness.
40	func truncateName(name string, maxLen int) string {	1,828✔
41	if maxLen < 10 {	1,828✔
42	maxLen = 10	×
43	}	×
44	if len(name) <= maxLen {	3,656✔
45	return name	1,828✔
46	}	1,828✔
47	hash := sha256.Sum256([]byte(name))	×
48	hashStr := hex.EncodeToString(hash[:])[:8]	×
49		×
50	return name[:maxLen-9] + "-" + hashStr	×
51	}
52
53	// mapRenderTaskToOwner returns a handler.MapFunc that maps RenderTask events
54	// to reconcile requests for the owning resource of the specified kind.
55	func mapRenderTaskToOwner(kind string) handler.MapFunc {	1✔
56	return func(_ context.Context, obj client.Object) []reconcile.Request {	167✔
57	rt, ok := obj.(*solarv1alpha1.RenderTask)	166✔
58	if !ok {	166✔
59	return nil	×
60	}	×
61
62	if rt.Spec.OwnerKind != kind \|\| rt.Spec.OwnerName == "" \|\| rt.Spec.OwnerNamespace == "" {	304✔
63	return nil	138✔
64	}	138✔
65
66	return []reconcile.Request{	28✔
67	{	28✔
68	NamespacedName: types.NamespacedName{	28✔
69	Name: rt.Spec.OwnerName,	28✔
70	Namespace: rt.Spec.OwnerNamespace,	28✔
71	},	28✔
72	},	28✔
73	}	28✔
74	}
75	}
76
77	// releaseRenderTaskName returns a deterministic name for a per-release RenderTask
78	// scoped to a specific target. Each target creates its own release RenderTasks;
79	// the renderer job handles deduplication by skipping rendering if the chart
80	// already exists in the registry.
81	func releaseRenderTaskName(releaseName, targetName string, generation int64) string {	33✔
82	input := fmt.Sprintf("%s-%s-%d", releaseName, targetName, generation)	33✔
83	hash := sha256.Sum256([]byte(input))	33✔
84	hashStr := hex.EncodeToString(hash[:])[:8]	33✔
85		33✔
86	return truncateName(fmt.Sprintf("render-rel-%s-%s", releaseName, hashStr), maxK8sObjectNameLen)	33✔
87	}	33✔
88
89	// targetRenderTaskName returns a deterministic name for a per-target bootstrap RenderTask.
90	// The bootstrapVersion is incremented each time the bootstrap needs re-rendering.
91	func targetRenderTaskName(targetName string, bootstrapVersion int64) string {	15✔
92	return truncateName(fmt.Sprintf("render-tgt-%s-%d", targetName, bootstrapVersion), maxK8sObjectNameLen)	15✔
93	}	15✔
94
95	// IndexFields registers field indexers on the manager for efficient lookups.
96	// Must be called once before any controller that uses these indexes is set up.
97	func IndexFields(ctx context.Context, mgr ctrl.Manager) error {	1✔
98	if err := indexReleaseBindingFields(ctx, mgr); err != nil {	1✔
99	return err	×
100	}	×
101
102	if err := indexRegistryBindingFields(ctx, mgr); err != nil {	1✔
NEW 103	return err	×
NEW 104	}	×
105
106	return indexRenderTaskOwnerFields(ctx, mgr)	1✔
107	}
108
109	func indexReleaseBindingFields(ctx context.Context, mgr ctrl.Manager) error {	1✔
110	indexer := mgr.GetFieldIndexer()	1✔
111		1✔
112	if err := indexer.IndexField(ctx, &solarv1alpha1.ReleaseBinding{}, indexReleaseBindingTargetName, func(obj client.Object) []string {	11✔
113	rb := obj.(*solarv1alpha1.ReleaseBinding)	10✔
114	if rb.Spec.TargetRef.Name == "" {	10✔
115	return nil	×
116	}	×
117
118	return []string{rb.Spec.TargetRef.Name}	10✔
119	}); err != nil {	×
120	return err	×
121	}	×
122
123	return indexer.IndexField(ctx, &solarv1alpha1.ReleaseBinding{}, indexReleaseBindingReleaseName, func(obj client.Object) []string {	11✔
124	rb := obj.(*solarv1alpha1.ReleaseBinding)	10✔
125	if rb.Spec.ReleaseRef.Name == "" {	10✔
126	return nil	×
127	}	×
128
129	return []string{rb.Spec.ReleaseRef.Name}	10✔
130	})
131	}
132
133	func indexRegistryBindingFields(ctx context.Context, mgr ctrl.Manager) error {	1✔
134	return mgr.GetFieldIndexer().IndexField(ctx, &solarv1alpha1.RegistryBinding{}, indexRegistryBindingTargetName, func(obj client.Object) []string {	4✔
135	rb := obj.(*solarv1alpha1.RegistryBinding)	3✔
136	if rb.Spec.TargetRef.Name == "" {	3✔
NEW 137	return nil	×
NEW 138	}	×
139
140	return []string{rb.Spec.TargetRef.Name}	3✔
141	})
142	}
143
144	// indexRenderTaskOwnerFields registers field indexers on the manager for
145	// looking up RenderTasks by owner kind, name, and namespace.
146	func indexRenderTaskOwnerFields(ctx context.Context, mgr ctrl.Manager) error {	1✔
147	indexer := mgr.GetFieldIndexer()	1✔
148		1✔
149	if err := indexer.IndexField(ctx, &solarv1alpha1.RenderTask{}, indexOwnerKind, func(obj client.Object) []string {	167✔
150	rt := obj.(*solarv1alpha1.RenderTask)	166✔
151	if rt.Spec.OwnerKind == "" {	304✔
152	return nil	138✔
153	}	138✔
154
155	return []string{rt.Spec.OwnerKind}	28✔
156	}); err != nil {	×
157	return err	×
158	}	×
159
160	if err := indexer.IndexField(ctx, &solarv1alpha1.RenderTask{}, indexOwnerName, func(obj client.Object) []string {	167✔
161	rt := obj.(*solarv1alpha1.RenderTask)	166✔
162	if rt.Spec.OwnerName == "" {	304✔
163	return nil	138✔
164	}	138✔
165
166	return []string{rt.Spec.OwnerName}	28✔
167	}); err != nil {	×
168	return err	×
169	}	×
170
171	return indexer.IndexField(ctx, &solarv1alpha1.RenderTask{}, indexOwnerNamespace, func(obj client.Object) []string {	167✔
172	rt := obj.(*solarv1alpha1.RenderTask)	166✔
173	if rt.Spec.OwnerNamespace == "" {	304✔
174	return nil	138✔
175	}	138✔
176
177	return []string{rt.Spec.OwnerNamespace}	28✔
178	})
179	}

opendefensecloud / solution-arsenal / 24822429227

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