Merge pull request #81 from CrystalChun/update-cvo

MGMT-19877: Trigger workload cluster upgrade

Author: openshift-merge-bot[bot]

Diff for: controlplane/internal/controller/openshiftassistedcontrolplane_controller.go

@@ -190,8 +190,11 @@ func (r *OpenshiftAssistedControlPlaneReconciler) Reconcile(ctx context.Context,
 	}
 
 	if upgrade.IsUpgradeRequested(ctx, oacp) {
-		//TODO: Handle upgrade request
-		log.Info("upgrade for control plane has been requested")
+		log.Info("workload cluster upgrade has been requested, starting upgrade", "current workload cluster version", oacp.Status.DistributionVersion, "new workload cluster version", oacp.Spec.DistributionVersion)
+		if err := upgrade.UpgradeWorkloadCluster(ctx, r.Client, r.WorkloadClusterClientGenerator, oacp); err != nil {
+			log.Error(err, "failed to upgrade workload cluster")
+		}
+		log.Info("workload cluster upgrade set on ClusterVersion, waiting completion")
 	}
 	return ctrl.Result{}, r.reconcileReplicas(ctx, oacp, cluster)
 }

Diff for: controlplane/internal/upgrade/upgrade.go

@@ -20,6 +20,14 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+const (
+	// UpgradeImageOverrideAnnotation is a (temporary) solution to provide an upgrade image to CVO
+	// It is used while the OCP version being used for testing is not GA and should not be necessary if
+	// a GA version of OCP is used.
+	// Example: GA version = 4.19.0, Non-GA = 4.19.0-0.nightly-2025-01-30-091858
+	UpgradeImageOverrideAnnotation = "cluster.x-k8s.io/upgrade-image-override"
+)
+
 func IsUpgradeRequested(ctx context.Context, oacp *controlplanev1alpha2.OpenshiftAssistedControlPlane) bool {
 	log := ctrl.LoggerFrom(ctx)
 	oacpDistVersion, err := semver.NewVersion(oacp.Spec.DistributionVersion)
@@ -103,3 +111,33 @@ func isKubeconfigAvailable(oacp *controlplanev1alpha2.OpenshiftAssistedControlPl
 	}
 	return kubeconfigFoundCondition.Status == corev1.ConditionTrue
 }
+
+func UpgradeWorkloadCluster(ctx context.Context, client client.Client,
+	workloadClusterClientGenerator workloadclient.ClientGenerator,
+	oacp *controlplanev1alpha2.OpenshiftAssistedControlPlane) error {
+	workloadClient, err := getWorkloadClient(ctx, client, workloadClusterClientGenerator, oacp)
+	if err != nil {
+		return err
+	}
+
+	if workloadClient == nil {
+		return fmt.Errorf("workload client is not available yet")
+	}
+
+	var clusterVersion configv1.ClusterVersion
+	if err := workloadClient.Get(ctx, types.NamespacedName{Name: "version"}, &clusterVersion); err != nil {
+		err = errors.Join(err, fmt.Errorf(("failed to get ClusterVersion from workload cluster")))
+		return err
+	}
+
+	clusterVersion.Spec.DesiredUpdate = &configv1.Update{
+		Version: oacp.Spec.DistributionVersion,
+	}
+
+	if releaseImage, ok := oacp.Annotations[UpgradeImageOverrideAnnotation]; ok {
+		clusterVersion.Spec.DesiredUpdate.Image = releaseImage
+		clusterVersion.Spec.DesiredUpdate.Force = true
+	}
+
+	return workloadClient.Update(ctx, &clusterVersion)
+}

Diff for: controlplane/internal/upgrade/upgrade_test.go

@@ -160,6 +160,78 @@ var _ = Describe("Upgrade", func() {
 			})
 		})
 	})
+	Context("Upgrading", func() {
+		const (
+			openshiftAssistedControlPlaneName = "test-resource"
+			clusterName                       = "test-cluster"
+			namespace                         = "test"
+		)
+		var (
+			ctx                         = context.Background()
+			cluster                     *clusterv1.Cluster
+			mockCtrl                    *gomock.Controller
+			k8sClient                   client.Client
+			mockWorkloadClientGenerator *mockWorkloadClient
+		)
+		BeforeEach(func() {
+			k8sClient = fakeclient.NewClientBuilder().
+				WithScheme(testScheme).
+				WithStatusSubresource(&controlplanev1alpha2.OpenshiftAssistedControlPlane{}).Build()
+
+			mockCtrl = gomock.NewController(GinkgoT())
+			ns := &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}
+			Expect(k8sClient.Create(ctx, ns)).To(Succeed())
+
+			mockWorkloadClientGenerator = NewMockWorkloadClient()
+
+			By("creating a cluster")
+			cluster = &clusterv1.Cluster{}
+			err := k8sClient.Get(ctx, types.NamespacedName{Name: clusterName, Namespace: namespace}, cluster)
+			if err != nil && errors.IsNotFound(err) {
+				cluster = testutils.NewCluster(clusterName, namespace)
+				err := k8sClient.Create(ctx, cluster)
+				Expect(err).NotTo(HaveOccurred())
+			}
+		})
+
+		AfterEach(func() {
+			mockCtrl.Finish()
+			k8sClient = nil
+		})
+		When("Upgrade is requested", func() {
+			It("should update the workload cluster's cluster version to have the correct desired update", func() {
+				By("creating the openshift assisted control plane")
+				openshiftAssistedControlPlane := testutils.NewOpenshiftAssistedControlPlane(namespace, openshiftAssistedControlPlaneName)
+				openshiftAssistedControlPlane.Status.DistributionVersion = "4.12.0"
+				openshiftAssistedControlPlane.Labels = map[string]string{
+					clusterv1.ClusterNameLabel: cluster.Name,
+				}
+				conditions.MarkTrue(openshiftAssistedControlPlane, controlplanev1alpha2.KubeconfigAvailableCondition)
+				By("creating the kubeconfig secret")
+				kubeconfigSecret := &corev1.Secret{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      fmt.Sprintf("%s-kubeconfig", cluster.Name),
+						Namespace: openshiftAssistedControlPlane.Namespace,
+					},
+					Data: map[string][]byte{
+						"value": []byte("kubeconfig"),
+					},
+				}
+				Expect(k8sClient.Create(ctx, kubeconfigSecret)).To(Succeed())
+				By("creating a cluster version using the workload cluster's client")
+				mockWorkloadClientGenerator.MockCreateClusterVersion("4.12.0")
+
+				By("calling UpgradeWorkloadCluster")
+				Expect(UpgradeWorkloadCluster(ctx, k8sClient, mockWorkloadClientGenerator, openshiftAssistedControlPlane)).To(Succeed())
+
+				By("checking the workload cluster's cluster version for the desired update field")
+				workloadClusterVersion := &configv1.ClusterVersion{}
+				Expect(mockWorkloadClientGenerator.mockClient.Get(ctx, types.NamespacedName{Name: "version"}, workloadClusterVersion)).To(Succeed())
+				Expect(workloadClusterVersion.Spec.DesiredUpdate).NotTo(BeNil())
+				Expect(workloadClusterVersion.Spec.DesiredUpdate.Version).To(Equal(openshiftAssistedControlPlane.Spec.DistributionVersion))
+			})
+		})
+	})
 })
 
 type mockWorkloadClient struct {