19192074357

Committed 08 Nov 2025 10:56AM UTC coverage: 66.1% (+2.7%) from 63.42%

Build # 19192074357

Build Type

Pull #150

github

Committed by

web-flow

Commit Message

Merge 003af39f9 into 366233455

Pull Request Pull Request #150: controller: Deploy upgraded daemonsets depending from plan

Run Details

135 of 157 new or added lines in 3 files covered. (85.99%)

1 existing line in 1 file now uncovered.

934 of 1413 relevant lines covered (66.1%)

10.12 hits per line

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

55.7

/pkg/upgrade-controller/controller/controller.go

package controller

import (
        "context"
        "fmt"
        "os"
        "time"

        "github.com/go-logr/logr"
        api "github.com/heathcliff26/kube-upgrade/pkg/apis/kubeupgrade/v1alpha2"
        "github.com/heathcliff26/kube-upgrade/pkg/client/clientset/versioned/scheme"
        "github.com/heathcliff26/kube-upgrade/pkg/constants"
        "golang.org/x/mod/semver"
        appv1 "k8s.io/api/apps/v1"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/rest"
        "k8s.io/klog/v2"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
        "sigs.k8s.io/controller-runtime/pkg/healthz"
        "sigs.k8s.io/controller-runtime/pkg/manager"
        "sigs.k8s.io/controller-runtime/pkg/manager/signals"
)

func init() {
        ctrl.SetLogger(klog.NewKlogr())
}

type controller struct {
        client.Client
        manager       manager.Manager
        client        kubernetes.Interface
        namespace     string
        upgradedImage string
}

// Run make generate when changing these comments
// +kubebuilder:rbac:groups=kubeupgrade.heathcliff.eu,resources=kubeupgradeplans,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=kubeupgrade.heathcliff.eu,resources=kubeupgradeplans/status,verbs=get;update;patch
// +kubebuilder:rbac:groups="",resources=nodes,verbs=list;update
func NewController(name string) (*controller, error) {
        config, err := rest.InClusterConfig()
        if err != nil {
                return nil, err
        }
        client, err := kubernetes.NewForConfig(config)
        if err != nil {
                return nil, err
        }

        ns, err := GetNamespace()
        if err != nil {
                return nil, err
        }

        mgr, err := ctrl.NewManager(config, manager.Options{
                Scheme:                        scheme.Scheme,
                LeaderElection:                true,
                LeaderElectionNamespace:       ns,
                LeaderElectionID:              name,
                LeaderElectionReleaseOnCancel: true,
                LeaseDuration:                 Pointer(time.Minute),
                RenewDeadline:                 Pointer(10 * time.Second),
                RetryPeriod:                   Pointer(5 * time.Second),
                HealthProbeBindAddress:        ":9090",
        })
        if err != nil {
                return nil, err
        }
        err = mgr.AddHealthzCheck("healthz", healthz.Ping)
        if err != nil {
                return nil, err
        }
        err = mgr.AddReadyzCheck("readyz", healthz.Ping)
        if err != nil {
                return nil, err
        }

        upgradedImage := os.Getenv("UPGRADED_IMAGE")
        if upgradedImage == "" {
                return nil, fmt.Errorf("UPGRADED_IMAGE environment variable is not set")
        }

        return &controller{
                Client:        mgr.GetClient(),
                manager:       mgr,
                client:        client,
                namespace:     ns,
                upgradedImage: upgradedImage,
        }, nil
}

func (c *controller) Run() error {
        err := ctrl.NewControllerManagedBy(c.manager).For(&api.KubeUpgradePlan{}).Complete(c)
        if err != nil {
                return err
        }

        err = ctrl.NewWebhookManagedBy(c.manager).
                For(&api.KubeUpgradePlan{}).
                WithDefaulter(&planMutatingHook{}).
                WithValidator(&planValidatingHook{}).
                Complete()
        if err != nil {
                return err
        }

        return c.manager.Start(signals.SetupSignalHandler())
}

func (c *controller) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
        logger := klog.LoggerWithValues(klog.NewKlogr(), "plan", req.Name)

        var plan api.KubeUpgradePlan
        err := c.Get(ctx, req.NamespacedName, &plan)
        if err != nil {
                logger.Error(err, "Failed to get Plan")
                return ctrl.Result{}, err
        }

        err = c.reconcile(ctx, &plan, logger)
        if err != nil {
                return ctrl.Result{}, err
        }

        err = c.Status().Update(ctx, &plan)
        if err != nil {
                logger.Error(err, "Failed to update plan status")
                return ctrl.Result{}, err
        }

        return ctrl.Result{
                Requeue:      plan.Status.Summary != api.PlanStatusComplete,
                RequeueAfter: time.Minute,
        }, nil
}

func (c *controller) reconcile(ctx context.Context, plan *api.KubeUpgradePlan, logger logr.Logger) error {
        if plan.Status.Groups == nil {
                plan.Status.Groups = make(map[string]string, len(plan.Spec.Groups))
        }

        if controllerutil.AddFinalizer(plan, constants.Finalizer) {
                err := c.Update(ctx, plan)
                if err != nil {
                        return fmt.Errorf("failed to add finalizer to plan %s: %v", plan.Name, err)
                }
        }

        daemonsList, err := c.client.AppsV1().DaemonSets(c.namespace).List(ctx, metav1.ListOptions{
                LabelSelector: fmt.Sprintf("%s=%s", constants.LabelPlanName, plan.Name),
        })
        if err != nil {
                logger.WithValues("plan", plan.Name).Error(err, "Failed to fetch upgraded daemonsets")
                return err
        }

        if !plan.DeletionTimestamp.IsZero() {
                logger.WithValues("plan", plan.Name).Info("Plan is being deleted, cleaning up resources")
                for _, daemon := range daemonsList.Items {
                        err := c.client.AppsV1().DaemonSets(c.namespace).Delete(ctx, daemon.Name, metav1.DeleteOptions{})
                        if err != nil {
                                return fmt.Errorf("failed to delete DaemonSet %s: %v", daemon.Name, err)
                        }
                        logger.WithValues("daemon", daemon.Name).Info("Deleted DaemonSet")
                }
                controllerutil.RemoveFinalizer(plan, constants.Finalizer)
                err := c.Update(ctx, plan)
                if err != nil {
                        return fmt.Errorf("failed to remove finalizer from plan %s: %v", plan.Name, err)
                }
                logger.WithValues("plan", plan.Name).Info("Finished cleanup of resources")
                return nil
        }

        daemons := make(map[string]appv1.DaemonSet, len(plan.Spec.Groups))

        for _, daemon := range daemonsList.Items {
                group := daemon.Labels[constants.LabelNodeGroup]
                if _, ok := plan.Spec.Groups[group]; ok {
                        daemons[group] = daemon
                } else {
                        err := c.client.AppsV1().DaemonSets(c.namespace).Delete(ctx, daemon.Name, metav1.DeleteOptions{})
                        if err != nil {
                                return fmt.Errorf("failed to delete DaemonSet %s: %v", daemon.Name, err)
                        }
                        logger.WithValues("daemon", daemon.Name).Info("Deleted obsolete DaemonSet")
                }
        }

        nodesToUpdate := make(map[string][]corev1.Node, len(plan.Spec.Groups))
        newGroupStatus := make(map[string]string, len(plan.Spec.Groups))

        for name, cfg := range plan.Spec.Groups {
                upgradedCfg := combineConfig(plan.Spec.Upgraded, plan.Spec.Groups[name].Upgraded)

                selector, err := metav1.LabelSelectorAsSelector(cfg.Labels)
                if err != nil {
                        logger.WithValues("group", name).Error(err, "Failed to convert labelSelector to selector for listing nodes")
                        return err
                }

                daemon, ok := daemons[name]
                if !ok {
                        daemon = c.NewEmptyUpgradedDaemonSet(plan.Name, name)
                }
                daemon.Spec = c.NewUpgradedDaemonSetSpec(plan.Name, name)
                daemon.Spec.Template.Spec.NodeSelector = cfg.Labels.MatchLabels
                if ok {
                        _, err = c.client.AppsV1().DaemonSets(c.namespace).Update(ctx, &daemon, metav1.UpdateOptions{})
                } else {
                        logger.WithValues("group", name, "daemon", daemon.Name).Info("Creating upgraded DaemonSet for group")
                        _, err = c.client.AppsV1().DaemonSets(c.namespace).Create(ctx, &daemon, metav1.CreateOptions{})
                }
                if err != nil {
                        return fmt.Errorf("failed to create/update DaemonSet %s: %v", daemon.Name, err)
                }

                nodeList, err := c.client.CoreV1().Nodes().List(ctx, metav1.ListOptions{
                        LabelSelector: selector.String(),
                })
                if err != nil {
                        logger.WithValues("group", name).Error(err, "Failed to get nodes for group")
                        return err
                }

                status, update, nodes, err := c.reconcileNodes(plan.Spec.KubernetesVersion, plan.Spec.AllowDowngrade, nodeList.Items, upgradedCfg)
                if err != nil {
                        logger.WithValues("group", name).Error(err, "Failed to reconcile nodes for group")
                        return err
                }

                newGroupStatus[name] = status

                if update {
                        nodesToUpdate[name] = nodes
                } else if plan.Status.Groups[name] != newGroupStatus[name] {
                        logger.WithValues("group", name, "status", newGroupStatus[name]).Info("Group changed status")
                }
        }

        for name, nodes := range nodesToUpdate {
                if groupWaitForDependency(plan.Spec.Groups[name].DependsOn, newGroupStatus) {
                        logger.WithValues("group", name).Info("Group is waiting on dependencies")
                        newGroupStatus[name] = api.PlanStatusWaiting
                        continue
                } else if plan.Status.Groups[name] != newGroupStatus[name] {
                        logger.WithValues("group", name, "status", newGroupStatus[name]).Info("Group changed status")
                }

                for _, node := range nodes {
                        _, err := c.client.CoreV1().Nodes().Update(ctx, &node, metav1.UpdateOptions{})
                        if err != nil {
                                return fmt.Errorf("failed to update node %s: %v", node.GetName(), err)
                        }
                }
        }

        plan.Status.Groups = newGroupStatus
        plan.Status.Summary = createStatusSummary(plan.Status.Groups)

        return nil
}

func (c *controller) reconcileNodes(kubeVersion string, downgrade bool, nodes []corev1.Node, cfgAnnotations map[string]string) (string, bool, []corev1.Node, error) {
        if len(nodes) == 0 {
                return api.PlanStatusUnknown, false, nil, nil
        }

        completed := 0
        needUpdate := false
        errorNodes := make([]string, 0)

        for i := range nodes {
                if nodes[i].Annotations == nil {
                        nodes[i].Annotations = make(map[string]string)
                }

                if applyConfigAnnotations(nodes[i].Annotations, cfgAnnotations) {
                        needUpdate = true
                }

                if !downgrade && semver.Compare(kubeVersion, nodes[i].Status.NodeInfo.KubeletVersion) < 0 {
                        return api.PlanStatusError, false, nil, fmt.Errorf("node %s version %s is newer than %s, but downgrade is disabled", nodes[i].GetName(), nodes[i].Status.NodeInfo.KubeletVersion, kubeVersion)
                }

                if nodes[i].Annotations[constants.NodeKubernetesVersion] == kubeVersion {
                        switch nodes[i].Annotations[constants.NodeUpgradeStatus] {
                        case constants.NodeUpgradeStatusCompleted:
                                completed++
                        case constants.NodeUpgradeStatusError:
                                errorNodes = append(errorNodes, nodes[i].GetName())
                        }
                        continue
                }

                nodes[i].Annotations[constants.NodeKubernetesVersion] = kubeVersion
                nodes[i].Annotations[constants.NodeUpgradeStatus] = constants.NodeUpgradeStatusPending

                needUpdate = true
        }

        var status string
        if len(errorNodes) > 0 {
                status = fmt.Sprintf("%s: The nodes %v are reporting errors", api.PlanStatusError, errorNodes)
        } else if len(nodes) == completed {
                status = api.PlanStatusComplete
        } else {
                status = fmt.Sprintf("%s: %d/%d nodes upgraded", api.PlanStatusProgressing, completed, len(nodes))
        }
        return status, needUpdate, nodes, nil
}

1	package controller
2
3	import (
4	"context"
5	"fmt"
6	"os"
7	"time"
8
9	"github.com/go-logr/logr"
10	api "github.com/heathcliff26/kube-upgrade/pkg/apis/kubeupgrade/v1alpha2"
11	"github.com/heathcliff26/kube-upgrade/pkg/client/clientset/versioned/scheme"
12	"github.com/heathcliff26/kube-upgrade/pkg/constants"
13	"golang.org/x/mod/semver"
14	appv1 "k8s.io/api/apps/v1"
15	corev1 "k8s.io/api/core/v1"
16	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
17	"k8s.io/client-go/kubernetes"
18	"k8s.io/client-go/rest"
19	"k8s.io/klog/v2"
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	"sigs.k8s.io/controller-runtime/pkg/healthz"
24	"sigs.k8s.io/controller-runtime/pkg/manager"
25	"sigs.k8s.io/controller-runtime/pkg/manager/signals"
26	)
27
28	func init() {	2✔
29	ctrl.SetLogger(klog.NewKlogr())	2✔
30	}	2✔
31
32	type controller struct {
33	client.Client
34	manager manager.Manager
35	client kubernetes.Interface
36	namespace string
37	upgradedImage string
38	}
39
40	// Run make generate when changing these comments
41	// +kubebuilder:rbac:groups=kubeupgrade.heathcliff.eu,resources=kubeupgradeplans,verbs=get;list;watch;create;update;patch;delete
42	// +kubebuilder:rbac:groups=kubeupgrade.heathcliff.eu,resources=kubeupgradeplans/status,verbs=get;update;patch
43	// +kubebuilder:rbac:groups="",resources=nodes,verbs=list;update
44	func NewController(name string) (*controller, error) {	1✔
45	config, err := rest.InClusterConfig()	1✔
46	if err != nil {	2✔
47	return nil, err	1✔
48	}	1✔
49	client, err := kubernetes.NewForConfig(config)	×
50	if err != nil {	×
51	return nil, err	×
52	}	×
53
54	ns, err := GetNamespace()	×
55	if err != nil {	×
56	return nil, err	×
57	}	×
58
59	mgr, err := ctrl.NewManager(config, manager.Options{	×
60	Scheme: scheme.Scheme,	×
61	LeaderElection: true,	×
62	LeaderElectionNamespace: ns,	×
63	LeaderElectionID: name,	×
64	LeaderElectionReleaseOnCancel: true,	×
65	LeaseDuration: Pointer(time.Minute),	×
66	RenewDeadline: Pointer(10 * time.Second),	×
67	RetryPeriod: Pointer(5 * time.Second),	×
68	HealthProbeBindAddress: ":9090",	×
69	})	×
70	if err != nil {	×
71	return nil, err	×
72	}	×
73	err = mgr.AddHealthzCheck("healthz", healthz.Ping)	×
74	if err != nil {	×
75	return nil, err	×
76	}	×
77	err = mgr.AddReadyzCheck("readyz", healthz.Ping)	×
78	if err != nil {	×
79	return nil, err	×
80	}	×
81
NEW 82	upgradedImage := os.Getenv("UPGRADED_IMAGE")	×
NEW 83	if upgradedImage == "" {	×
NEW 84	return nil, fmt.Errorf("UPGRADED_IMAGE environment variable is not set")	×
NEW 85	}	×
86
87	return &controller{	×
NEW 88	Client: mgr.GetClient(),	×
NEW 89	manager: mgr,	×
NEW 90	client: client,	×
NEW 91	namespace: ns,	×
NEW 92	upgradedImage: upgradedImage,	×
UNCOV 93	}, nil	×
94	}
95
96	func (c *controller) Run() error {	×
97	err := ctrl.NewControllerManagedBy(c.manager).For(&api.KubeUpgradePlan{}).Complete(c)	×
98	if err != nil {	×
99	return err	×
100	}	×
101
102	err = ctrl.NewWebhookManagedBy(c.manager).	×
103	For(&api.KubeUpgradePlan{}).	×
104	WithDefaulter(&planMutatingHook{}).	×
105	WithValidator(&planValidatingHook{}).	×
106	Complete()	×
107	if err != nil {	×
108	return err	×
109	}	×
110
111	return c.manager.Start(signals.SetupSignalHandler())	×
112	}
113
114	func (c *controller) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	×
115	logger := klog.LoggerWithValues(klog.NewKlogr(), "plan", req.Name)	×
116		×
117	var plan api.KubeUpgradePlan	×
118	err := c.Get(ctx, req.NamespacedName, &plan)	×
119	if err != nil {	×
120	logger.Error(err, "Failed to get Plan")	×
121	return ctrl.Result{}, err	×
122	}	×
123
124	err = c.reconcile(ctx, &plan, logger)	×
125	if err != nil {	×
126	return ctrl.Result{}, err	×
127	}	×
128
129	err = c.Status().Update(ctx, &plan)	×
130	if err != nil {	×
131	logger.Error(err, "Failed to update plan status")	×
132	return ctrl.Result{}, err	×
133	}	×
134
135	return ctrl.Result{	×
136	Requeue: plan.Status.Summary != api.PlanStatusComplete,	×
137	RequeueAfter: time.Minute,	×
138	}, nil	×
139	}
140
141	func (c controller) reconcile(ctx context.Context, plan api.KubeUpgradePlan, logger logr.Logger) error {	17✔
142	if plan.Status.Groups == nil {	26✔
143	plan.Status.Groups = make(map[string]string, len(plan.Spec.Groups))	9✔
144	}	9✔
145
146	if controllerutil.AddFinalizer(plan, constants.Finalizer) {	33✔
147	err := c.Update(ctx, plan)	16✔
148	if err != nil {	16✔
NEW 149	return fmt.Errorf("failed to add finalizer to plan %s: %v", plan.Name, err)	×
NEW 150	}	×
151	}
152
153	daemonsList, err := c.client.AppsV1().DaemonSets(c.namespace).List(ctx, metav1.ListOptions{	17✔
154	LabelSelector: fmt.Sprintf("%s=%s", constants.LabelPlanName, plan.Name),	17✔
155	})	17✔
156	if err != nil {	17✔
NEW 157	logger.WithValues("plan", plan.Name).Error(err, "Failed to fetch upgraded daemonsets")	×
NEW 158	return err	×
NEW 159	}	×
160
161	if !plan.DeletionTimestamp.IsZero() {	18✔
162	logger.WithValues("plan", plan.Name).Info("Plan is being deleted, cleaning up resources")	1✔
163	for _, daemon := range daemonsList.Items {	2✔
164	err := c.client.AppsV1().DaemonSets(c.namespace).Delete(ctx, daemon.Name, metav1.DeleteOptions{})	1✔
165	if err != nil {	1✔
NEW 166	return fmt.Errorf("failed to delete DaemonSet %s: %v", daemon.Name, err)	×
NEW 167	}	×
168	logger.WithValues("daemon", daemon.Name).Info("Deleted DaemonSet")	1✔
169	}
170	controllerutil.RemoveFinalizer(plan, constants.Finalizer)	1✔
171	err := c.Update(ctx, plan)	1✔
172	if err != nil {	1✔
NEW 173	return fmt.Errorf("failed to remove finalizer from plan %s: %v", plan.Name, err)	×
NEW 174	}	×
175	logger.WithValues("plan", plan.Name).Info("Finished cleanup of resources")	1✔
176	return nil	1✔
177	}
178
179	daemons := make(map[string]appv1.DaemonSet, len(plan.Spec.Groups))	16✔
180		16✔
181	for _, daemon := range daemonsList.Items {	24✔
182	group := daemon.Labels[constants.LabelNodeGroup]	8✔
183	if _, ok := plan.Spec.Groups[group]; ok {	14✔
184	daemons[group] = daemon	6✔
185	} else {	8✔
186	err := c.client.AppsV1().DaemonSets(c.namespace).Delete(ctx, daemon.Name, metav1.DeleteOptions{})	2✔
187	if err != nil {	2✔
NEW 188	return fmt.Errorf("failed to delete DaemonSet %s: %v", daemon.Name, err)	×
NEW 189	}	×
190	logger.WithValues("daemon", daemon.Name).Info("Deleted obsolete DaemonSet")	2✔
191	}
192	}
193
194	nodesToUpdate := make(map[string][]corev1.Node, len(plan.Spec.Groups))	16✔
195	newGroupStatus := make(map[string]string, len(plan.Spec.Groups))	16✔
196		16✔
197	for name, cfg := range plan.Spec.Groups {	52✔
198	upgradedCfg := combineConfig(plan.Spec.Upgraded, plan.Spec.Groups[name].Upgraded)	36✔
199		36✔
200	selector, err := metav1.LabelSelectorAsSelector(cfg.Labels)	36✔
201	if err != nil {	36✔
202	logger.WithValues("group", name).Error(err, "Failed to convert labelSelector to selector for listing nodes")	×
203	return err	×
204	}	×
205
206	daemon, ok := daemons[name]	36✔
207	if !ok {	66✔
208	daemon = c.NewEmptyUpgradedDaemonSet(plan.Name, name)	30✔
209	}	30✔
210	daemon.Spec = c.NewUpgradedDaemonSetSpec(plan.Name, name)	36✔
211	daemon.Spec.Template.Spec.NodeSelector = cfg.Labels.MatchLabels	36✔
212	if ok {	42✔
213	_, err = c.client.AppsV1().DaemonSets(c.namespace).Update(ctx, &daemon, metav1.UpdateOptions{})	6✔
214	} else {	36✔
215	logger.WithValues("group", name, "daemon", daemon.Name).Info("Creating upgraded DaemonSet for group")	30✔
216	_, err = c.client.AppsV1().DaemonSets(c.namespace).Create(ctx, &daemon, metav1.CreateOptions{})	30✔
217	}	30✔
218	if err != nil {	36✔
NEW 219	return fmt.Errorf("failed to create/update DaemonSet %s: %v", daemon.Name, err)	×
NEW 220	}	×
221
222	nodeList, err := c.client.CoreV1().Nodes().List(ctx, metav1.ListOptions{	36✔
223	LabelSelector: selector.String(),	36✔
224	})	36✔
225	if err != nil {	36✔
226	logger.WithValues("group", name).Error(err, "Failed to get nodes for group")	×
227	return err	×
228	}	×
229
230	status, update, nodes, err := c.reconcileNodes(plan.Spec.KubernetesVersion, plan.Spec.AllowDowngrade, nodeList.Items, upgradedCfg)	36✔
231	if err != nil {	36✔
232	logger.WithValues("group", name).Error(err, "Failed to reconcile nodes for group")	×
233	return err	×
234	}	×
235
236	newGroupStatus[name] = status	36✔
237		36✔
238	if update {	58✔
239	nodesToUpdate[name] = nodes	22✔
240	} else if plan.Status.Groups[name] != newGroupStatus[name] {	46✔
241	logger.WithValues("group", name, "status", newGroupStatus[name]).Info("Group changed status")	10✔
242	}	10✔
243	}
244
245	for name, nodes := range nodesToUpdate {	38✔
246	if groupWaitForDependency(plan.Spec.Groups[name].DependsOn, newGroupStatus) {	28✔
247	logger.WithValues("group", name).Info("Group is waiting on dependencies")	6✔
248	newGroupStatus[name] = api.PlanStatusWaiting	6✔
249	continue	6✔
250	} else if plan.Status.Groups[name] != newGroupStatus[name] {	30✔
251	logger.WithValues("group", name, "status", newGroupStatus[name]).Info("Group changed status")	14✔
252	}	14✔
253
254	for _, node := range nodes {	36✔
255	_, err := c.client.CoreV1().Nodes().Update(ctx, &node, metav1.UpdateOptions{})	20✔
256	if err != nil {	20✔
257	return fmt.Errorf("failed to update node %s: %v", node.GetName(), err)	×
258	}	×
259	}
260	}
261
262	plan.Status.Groups = newGroupStatus	16✔
263	plan.Status.Summary = createStatusSummary(plan.Status.Groups)	16✔
264		16✔
265	return nil	16✔
266	}
267
268	func (c *controller) reconcileNodes(kubeVersion string, downgrade bool, nodes []corev1.Node, cfgAnnotations map[string]string) (string, bool, []corev1.Node, error) {	38✔
269	if len(nodes) == 0 {	42✔
270	return api.PlanStatusUnknown, false, nil, nil	4✔
271	}	4✔
272
273	completed := 0	34✔
274	needUpdate := false	34✔
275	errorNodes := make([]string, 0)	34✔
276		34✔
277	for i := range nodes {	72✔
278	if nodes[i].Annotations == nil {	61✔
279	nodes[i].Annotations = make(map[string]string)	23✔
280	}	23✔
281
282	if applyConfigAnnotations(nodes[i].Annotations, cfgAnnotations) {	40✔
283	needUpdate = true	2✔
284	}	2✔
285
286	if !downgrade && semver.Compare(kubeVersion, nodes[i].Status.NodeInfo.KubeletVersion) < 0 {	39✔
287	return api.PlanStatusError, false, nil, fmt.Errorf("node %s version %s is newer than %s, but downgrade is disabled", nodes[i].GetName(), nodes[i].Status.NodeInfo.KubeletVersion, kubeVersion)	1✔
288	}	1✔
289
290	if nodes[i].Annotations[constants.NodeKubernetesVersion] == kubeVersion {	49✔
291	switch nodes[i].Annotations[constants.NodeUpgradeStatus] {	12✔
292	case constants.NodeUpgradeStatusCompleted:	11✔
293	completed++	11✔
294	case constants.NodeUpgradeStatusError:	1✔
295	errorNodes = append(errorNodes, nodes[i].GetName())	1✔
296	}
297	continue	12✔
298	}
299
300	nodes[i].Annotations[constants.NodeKubernetesVersion] = kubeVersion	25✔
301	nodes[i].Annotations[constants.NodeUpgradeStatus] = constants.NodeUpgradeStatusPending	25✔
302		25✔
303	needUpdate = true	25✔
304	}
305
306	var status string	33✔
307	if len(errorNodes) > 0 {	34✔
308	status = fmt.Sprintf("%s: The nodes %v are reporting errors", api.PlanStatusError, errorNodes)	1✔
309	} else if len(nodes) == completed {	44✔
310	status = api.PlanStatusComplete	11✔
311	} else {	32✔
312	status = fmt.Sprintf("%s: %d/%d nodes upgraded", api.PlanStatusProgressing, completed, len(nodes))	21✔
313	}	21✔
314	return status, needUpdate, nodes, nil	33✔
315	}

heathcliff26 / kube-upgrade / 19192074357

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