17315172645

Committed 29 Aug 2025 05:05AM UTC coverage: 72.24% (+0.02%) from 72.217%

Build # 17315172645

Build Type

Pull #3735

github

Committed by

web-flow

Commit Message

Bump AAQ to v1.3.1

Signed-off-by: HCO Bump Bot <noreply@github.com>

Pull Request Pull Request #3735: [release-1.14] Bump AAQ to v1.3.1

Run Details

6464 of 8948 relevant lines covered (72.24%)

0.8 hits per line

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

82.14

/controllers/operands/quickStart.go

package operands

import (
        "errors"
        "os"
        filepath "path/filepath"
        "reflect"
        "strings"

        log "github.com/go-logr/logr"
        consolev1 "github.com/openshift/api/console/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"

        hcov1beta1 "github.com/kubevirt/hyperconverged-cluster-operator/api/v1beta1"
        "github.com/kubevirt/hyperconverged-cluster-operator/controllers/common"
        "github.com/kubevirt/hyperconverged-cluster-operator/pkg/util"
)

// ConsoleQuickStart resources are a short user guids
const (
        quickStartManifestLocationVarName = "QUICK_START_FILES_LOCATION"
        quickStartDefaultManifestLocation = "./quickStart"
)

var quickstartNames []string

func newQuickStartHandler(Client client.Client, Scheme *runtime.Scheme, required *consolev1.ConsoleQuickStart) Operand {
        h := &genericOperand{
                Client: Client,
                Scheme: Scheme,
                crType: "ConsoleQuickStart",
                hooks:  &qsHooks{required: required},
        }

        return h
}

type qsHooks struct {
        required *consolev1.ConsoleQuickStart
}

func (h qsHooks) getFullCr(_ *hcov1beta1.HyperConverged) (client.Object, error) {
        return h.required.DeepCopy(), nil
}

func (h qsHooks) getEmptyCr() client.Object {
        return &consolev1.ConsoleQuickStart{
                ObjectMeta: metav1.ObjectMeta{
                        Name: h.required.Name,
                },
        }
}

func (h qsHooks) updateCr(req *common.HcoRequest, Client client.Client, exists runtime.Object, _ runtime.Object) (bool, bool, error) {
        found, ok := exists.(*consolev1.ConsoleQuickStart)

        if !ok {
                return false, false, errors.New("can't convert to ConsoleQuickStart")
        }

        if !reflect.DeepEqual(h.required.Spec, found.Spec) ||
                !util.CompareLabels(h.required, found) {
                if req.HCOTriggered {
                        req.Logger.Info("Updating existing ConsoleQuickStart's Spec to new opinionated values", "name", h.required.Name)
                } else {
                        req.Logger.Info("Reconciling an externally updated ConsoleQuickStart's Spec to its opinionated values", "name", h.required.Name)
                }
                util.MergeLabels(&h.required.ObjectMeta, &found.ObjectMeta)
                h.required.Spec.DeepCopyInto(&found.Spec)
                err := Client.Update(req.Ctx, found)
                if err != nil {
                        return false, false, err
                }
                return true, !req.HCOTriggered, nil
        }

        return false, false, nil
}

func (qsHooks) justBeforeComplete(_ *common.HcoRequest) { /* no implementation */ }

func getQuickStartHandlers(logger log.Logger, Client client.Client, Scheme *runtime.Scheme, hc *hcov1beta1.HyperConverged) ([]Operand, error) {
        filesLocation := util.GetManifestDirPath(quickStartManifestLocationVarName, quickStartDefaultManifestLocation)

        err := util.ValidateManifestDir(filesLocation)
        if err != nil {
                return nil, errors.Unwrap(err) // if not wrapped, then it's not an error that stops processing, and it return nil
        }

        return createQuickstartHandlersFromFiles(logger, Client, Scheme, hc, filesLocation)
}

func createQuickstartHandlersFromFiles(logger log.Logger, Client client.Client, Scheme *runtime.Scheme, hc *hcov1beta1.HyperConverged, filesLocation string) ([]Operand, error) {
        var handlers []Operand
        quickstartNames = []string{}

        err := filepath.Walk(filesLocation, func(path string, info os.FileInfo, err error) error {
                if err != nil {
                        return err
                }

                qs, err := processQuickstartFile(path, info, logger, hc, Client, Scheme)
                if err != nil {
                        return err
                }

                if qs != nil {
                        handlers = append(handlers, qs)
                }

                return nil
        })

        return handlers, err
}

func processQuickstartFile(path string, info os.FileInfo, logger log.Logger, hc *hcov1beta1.HyperConverged, Client client.Client, Scheme *runtime.Scheme) (Operand, error) {
        if !info.IsDir() && strings.HasSuffix(info.Name(), ".yaml") {
                file, err := os.Open(path)
                if err != nil {
                        logger.Error(err, "Can't open the quickStart yaml file", "file name", path)
                        return nil, err
                }

                qs := &consolev1.ConsoleQuickStart{}
                err = util.UnmarshalYamlFileToObject(file, qs)
                if err != nil {
                        logger.Error(err, "Can't generate a ConsoleQuickStart object from yaml file", "file name", path)
                } else {
                        qs.Labels = getLabels(hc, util.AppComponentCompute)
                        quickstartNames = append(quickstartNames, qs.Name)
                        return newQuickStartHandler(Client, Scheme, qs), nil
                }
        }
        return nil, nil
}

1	package operands
2
3	import (
4	"errors"
5	"os"
6	filepath "path/filepath"
7	"reflect"
8	"strings"
9
10	log "github.com/go-logr/logr"
11	consolev1 "github.com/openshift/api/console/v1"
12	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
13	"k8s.io/apimachinery/pkg/runtime"
14	"sigs.k8s.io/controller-runtime/pkg/client"
15
16	hcov1beta1 "github.com/kubevirt/hyperconverged-cluster-operator/api/v1beta1"
17	"github.com/kubevirt/hyperconverged-cluster-operator/controllers/common"
18	"github.com/kubevirt/hyperconverged-cluster-operator/pkg/util"
19	)
20
21	// ConsoleQuickStart resources are a short user guids
22	const (
23	quickStartManifestLocationVarName = "QUICK_START_FILES_LOCATION"
24	quickStartDefaultManifestLocation = "./quickStart"
25	)
26
27	var quickstartNames []string
28
29	func newQuickStartHandler(Client client.Client, Scheme runtime.Scheme, required consolev1.ConsoleQuickStart) Operand {	1✔
30	h := &genericOperand{	1✔
31	Client: Client,	1✔
32	Scheme: Scheme,	1✔
33	crType: "ConsoleQuickStart",	1✔
34	hooks: &qsHooks{required: required},	1✔
35	}	1✔
36		1✔
37	return h	1✔
38	}	1✔
39
40	type qsHooks struct {
41	required *consolev1.ConsoleQuickStart
42	}
43
44	func (h qsHooks) getFullCr(_ *hcov1beta1.HyperConverged) (client.Object, error) {	1✔
45	return h.required.DeepCopy(), nil	1✔
46	}	1✔
47
48	func (h qsHooks) getEmptyCr() client.Object {	1✔
49	return &consolev1.ConsoleQuickStart{	1✔
50	ObjectMeta: metav1.ObjectMeta{	1✔
51	Name: h.required.Name,	1✔
52	},	1✔
53	}	1✔
54	}	1✔
55
56	func (h qsHooks) updateCr(req *common.HcoRequest, Client client.Client, exists runtime.Object, _ runtime.Object) (bool, bool, error) {	1✔
57	found, ok := exists.(*consolev1.ConsoleQuickStart)	1✔
58		1✔
59	if !ok {	1✔
60	return false, false, errors.New("can't convert to ConsoleQuickStart")	×
61	}	×
62
63	if !reflect.DeepEqual(h.required.Spec, found.Spec) \|\|	1✔
64	!util.CompareLabels(h.required, found) {	2✔
65	if req.HCOTriggered {	2✔
66	req.Logger.Info("Updating existing ConsoleQuickStart's Spec to new opinionated values", "name", h.required.Name)	1✔
67	} else {	1✔
68	req.Logger.Info("Reconciling an externally updated ConsoleQuickStart's Spec to its opinionated values", "name", h.required.Name)	×
69	}	×
70	util.MergeLabels(&h.required.ObjectMeta, &found.ObjectMeta)	1✔
71	h.required.Spec.DeepCopyInto(&found.Spec)	1✔
72	err := Client.Update(req.Ctx, found)	1✔
73	if err != nil {	1✔
74	return false, false, err	×
75	}	×
76	return true, !req.HCOTriggered, nil	1✔
77	}
78
79	return false, false, nil	×
80	}
81
82	func (qsHooks) justBeforeComplete(_ common.HcoRequest) { / no implementation */ }	1✔
83
84	func getQuickStartHandlers(logger log.Logger, Client client.Client, Scheme runtime.Scheme, hc hcov1beta1.HyperConverged) ([]Operand, error) {	1✔
85	filesLocation := util.GetManifestDirPath(quickStartManifestLocationVarName, quickStartDefaultManifestLocation)	1✔
86		1✔
87	err := util.ValidateManifestDir(filesLocation)	1✔
88	if err != nil {	2✔
89	return nil, errors.Unwrap(err) // if not wrapped, then it's not an error that stops processing, and it return nil	1✔
90	}	1✔
91
92	return createQuickstartHandlersFromFiles(logger, Client, Scheme, hc, filesLocation)	1✔
93	}
94
95	func createQuickstartHandlersFromFiles(logger log.Logger, Client client.Client, Scheme runtime.Scheme, hc hcov1beta1.HyperConverged, filesLocation string) ([]Operand, error) {	1✔
96	var handlers []Operand	1✔
97	quickstartNames = []string{}	1✔
98		1✔
99	err := filepath.Walk(filesLocation, func(path string, info os.FileInfo, err error) error {	2✔
100	if err != nil {	1✔
101	return err	×
102	}	×
103
104	qs, err := processQuickstartFile(path, info, logger, hc, Client, Scheme)	1✔
105	if err != nil {	1✔
106	return err	×
107	}	×
108
109	if qs != nil {	2✔
110	handlers = append(handlers, qs)	1✔
111	}	1✔
112
113	return nil	1✔
114	})
115
116	return handlers, err	1✔
117	}
118
119	func processQuickstartFile(path string, info os.FileInfo, logger log.Logger, hc hcov1beta1.HyperConverged, Client client.Client, Scheme runtime.Scheme) (Operand, error) {	1✔
120	if !info.IsDir() && strings.HasSuffix(info.Name(), ".yaml") {	2✔
121	file, err := os.Open(path)	1✔
122	if err != nil {	1✔
123	logger.Error(err, "Can't open the quickStart yaml file", "file name", path)	×
124	return nil, err	×
125	}	×
126
127	qs := &consolev1.ConsoleQuickStart{}	1✔
128	err = util.UnmarshalYamlFileToObject(file, qs)	1✔
129	if err != nil {	1✔
130	logger.Error(err, "Can't generate a ConsoleQuickStart object from yaml file", "file name", path)	×
131	} else {	1✔
132	qs.Labels = getLabels(hc, util.AppComponentCompute)	1✔
133	quickstartNames = append(quickstartNames, qs.Name)	1✔
134	return newQuickStartHandler(Client, Scheme, qs), nil	1✔
135	}	1✔
136	}
137	return nil, nil	1✔
138	}

kubevirt / hyperconverged-cluster-operator / 17315172645

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