Add KCP feature to clusterctl alpha rollout

Signed-off-by: Tobias Giese <tobias.giese@mercedes-benz.com>
kubernetes-sigs · Jul 7, 2022 · 4747856 · 4747856
1 parent 8fdaa34
commit 4747856
Show file tree

Hide file tree

Showing 15 changed files with 380 additions and 35 deletions.
diff --git a/cmd/clusterctl/client/alpha/kubeadmcontrolplane.go b/cmd/clusterctl/client/alpha/kubeadmcontrolplane.go
@@ -0,0 +1,64 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package alpha
+
+import (
+	"github.com/pkg/errors"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/cluster"
+	controlplanev1 "sigs.k8s.io/cluster-api/controlplane/kubeadm/api/v1beta1"
+)
+
+// getKubeadmControlPlane retrieves the KubeadmControlPlane object corresponding to the name and namespace specified.
+func getKubeadmControlPlane(proxy cluster.Proxy, name, namespace string) (*controlplanev1.KubeadmControlPlane, error) {
+	mdObj := &controlplanev1.KubeadmControlPlane{}
+	c, err := proxy.NewClient()
+	if err != nil {
+		return nil, err
+	}
+	mdObjKey := client.ObjectKey{
+		Namespace: namespace,
+		Name:      name,
+	}
+	if err := c.Get(ctx, mdObjKey, mdObj); err != nil {
+		return nil, errors.Wrapf(err, "error reading KubeadmControlPlane %s/%s",
+			mdObjKey.Namespace, mdObjKey.Name)
+	}
+	return mdObj, nil
+}
+
+// patchKubeadmControlPlane applies a patch to a KubeadmControlPlane.
+func patchKubeadmControlPlane(proxy cluster.Proxy, name, namespace string, patch client.Patch) error {
+	cFrom, err := proxy.NewClient()
+	if err != nil {
+		return err
+	}
+	mdObj := &controlplanev1.KubeadmControlPlane{}
+	mdObjKey := client.ObjectKey{
+		Namespace: namespace,
+		Name:      name,
+	}
+	if err := cFrom.Get(ctx, mdObjKey, mdObj); err != nil {
+		return errors.Wrapf(err, "error reading KubeadmControlPlane %s/%s", mdObj.GetNamespace(), mdObj.GetName())
+	}
+
+	if err := cFrom.Patch(ctx, mdObj, patch); err != nil {
+		return errors.Wrapf(err, "error while patching KubeadmControlPlane %s/%s", mdObj.GetNamespace(), mdObj.GetName())
+	}
+	return nil
+}
diff --git a/cmd/clusterctl/client/alpha/rollout.go b/cmd/clusterctl/client/alpha/rollout.go
@@ -25,7 +25,13 @@ import (
 // MachineDeployment is a resource type.
 const MachineDeployment = "machinedeployment"
 
-var validResourceTypes = []string{MachineDeployment}
+// KubeadmControlPlane is a resource type.
+const KubeadmControlPlane = "kubeadmcontrolplane"
+
+var validResourceTypes = []string{
+	MachineDeployment,
+	KubeadmControlPlane,
+}
 
 // Rollout defines the behavior of a rollout implementation.
 type Rollout interface {

diff --git a/cmd/clusterctl/client/alpha/rollout_pauser.go b/cmd/clusterctl/client/alpha/rollout_pauser.go
@@ -24,7 +24,9 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
+	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/cluster"
+	"sigs.k8s.io/cluster-api/util/annotations"
 )
 
 // ObjectPauser will issue a pause on the specified cluster-api resource.
@@ -41,6 +43,17 @@ func (r *rollout) ObjectPauser(proxy cluster.Proxy, ref corev1.ObjectReference)
 		if err := pauseMachineDeployment(proxy, ref.Name, ref.Namespace); err != nil {
 			return err
 		}
+	case KubeadmControlPlane:
+		kcp, err := getKubeadmControlPlane(proxy, ref.Name, ref.Namespace)
+		if err != nil || kcp == nil {
+			return errors.Wrapf(err, "failed to fetch %v/%v", ref.Kind, ref.Name)
+		}
+		if annotations.HasPaused(kcp.GetObjectMeta()) {
+			return errors.Errorf("KubeadmControlPlane is already paused: %v/%v\n", ref.Kind, ref.Name) //nolint:revive // KubeadmControlPlane is intentionally capitalized.
+		}
+		if err := pauseKubeadmControlPlane(proxy, ref.Name, ref.Namespace); err != nil {
+			return err
+		}
 	default:
 		return errors.Errorf("Invalid resource type %q, valid values are %v", ref.Kind, validResourceTypes)
 	}
@@ -52,3 +65,9 @@ func pauseMachineDeployment(proxy cluster.Proxy, name, namespace string) error {
 	patch := client.RawPatch(types.MergePatchType, []byte(fmt.Sprintf("{\"spec\":{\"paused\":%t}}", true)))
 	return patchMachineDeployment(proxy, name, namespace, patch)
 }
+
+// pauseKubeadmControlPlane sets Paused to true in the KubeadmControlPlane's spec.
+func pauseKubeadmControlPlane(proxy cluster.Proxy, name, namespace string) error {
+	patch := client.RawPatch(types.MergePatchType, []byte(fmt.Sprintf("{\"metadata\":{\"annotations\":{%q: \"%t\"}}}", clusterv1.PausedAnnotation, true)))
+	return patchKubeadmControlPlane(proxy, name, namespace, patch)
+}
diff --git a/cmd/clusterctl/client/alpha/rollout_pauser_test.go b/cmd/clusterctl/client/alpha/rollout_pauser_test.go
@@ -27,6 +27,8 @@ import (
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/internal/test"
+	controlplanev1 "sigs.k8s.io/cluster-api/controlplane/kubeadm/api/v1beta1"
+	"sigs.k8s.io/cluster-api/util/annotations"
 )
 
 func Test_ObjectPauser(t *testing.T) {
@@ -36,12 +38,14 @@ func Test_ObjectPauser(t *testing.T) {
 	}
 	tests := []struct {
 		name       string
+		apiType    string
 		fields     fields
 		wantErr    bool
 		wantPaused bool
 	}{
 		{
-			name: "machinedeployment should be paused",
+			name:    "machinedeployment should be paused",
+			apiType: MachineDeployment,
 			fields: fields{
 				objs: []client.Object{
 					&clusterv1.MachineDeployment{
@@ -64,7 +68,8 @@ func Test_ObjectPauser(t *testing.T) {
 			wantPaused: true,
 		},
 		{
-			name: "re-pausing an already paused machinedeployment should return error",
+			name:    "re-pausing an already paused machinedeployment should return error",
+			apiType: MachineDeployment,
 			fields: fields{
 				objs: []client.Object{
 					&clusterv1.MachineDeployment{
@@ -89,6 +94,57 @@ func Test_ObjectPauser(t *testing.T) {
 			wantErr:    true,
 			wantPaused: false,
 		},
+		{
+			name:    "kubeadmcontrolplane should be paused",
+			apiType: KubeadmControlPlane,
+			fields: fields{
+				objs: []client.Object{
+					&controlplanev1.KubeadmControlPlane{
+						TypeMeta: metav1.TypeMeta{
+							Kind: "KubeadmControlPlane",
+						},
+						ObjectMeta: metav1.ObjectMeta{
+							Namespace: "default",
+							Name:      "kcp",
+						},
+					},
+				},
+				ref: corev1.ObjectReference{
+					Kind:      KubeadmControlPlane,
+					Name:      "kcp",
+					Namespace: "default",
+				},
+			},
+			wantErr:    false,
+			wantPaused: true,
+		},
+		{
+			name:    "re-pausing an already paused kubeadmcontrolplane should return error",
+			apiType: KubeadmControlPlane,
+			fields: fields{
+				objs: []client.Object{
+					&controlplanev1.KubeadmControlPlane{
+						TypeMeta: metav1.TypeMeta{
+							Kind: "KubeadmControlPlane",
+						},
+						ObjectMeta: metav1.ObjectMeta{
+							Namespace: "default",
+							Name:      "kcp",
+							Annotations: map[string]string{
+								clusterv1.PausedAnnotation: "true",
+							},
+						},
+					},
+				},
+				ref: corev1.ObjectReference{
+					Kind:      KubeadmControlPlane,
+					Name:      "kcp",
+					Namespace: "default",
+				},
+			},
+			wantErr:    true,
+			wantPaused: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -105,10 +161,18 @@ func Test_ObjectPauser(t *testing.T) {
 				cl, err := proxy.NewClient()
 				g.Expect(err).ToNot(HaveOccurred())
 				key := client.ObjectKeyFromObject(obj)
-				md := &clusterv1.MachineDeployment{}
-				err = cl.Get(context.TODO(), key, md)
-				g.Expect(err).ToNot(HaveOccurred())
-				g.Expect(md.Spec.Paused).To(Equal(tt.wantPaused))
+				switch tt.apiType {
+				case MachineDeployment:
+					md := &clusterv1.MachineDeployment{}
+					err = cl.Get(context.TODO(), key, md)
+					g.Expect(err).ToNot(HaveOccurred())
+					g.Expect(md.Spec.Paused).To(Equal(tt.wantPaused))
+				case KubeadmControlPlane:
+					kcp := &controlplanev1.KubeadmControlPlane{}
+					err = cl.Get(context.TODO(), key, kcp)
+					g.Expect(err).ToNot(HaveOccurred())
+					g.Expect(annotations.HasPaused(kcp.GetObjectMeta())).To(Equal(tt.wantPaused))
+				}
 			}
 		})
 	}

diff --git a/cmd/clusterctl/client/alpha/rollout_restarter.go b/cmd/clusterctl/client/alpha/rollout_restarter.go
@@ -26,6 +26,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/cluster"
+	"sigs.k8s.io/cluster-api/util/annotations"
 )
 
 // ObjectRestarter will issue a restart on the specified cluster-api resource.
@@ -42,6 +43,17 @@ func (r *rollout) ObjectRestarter(proxy cluster.Proxy, ref corev1.ObjectReferenc
 		if err := setRestartedAtAnnotation(proxy, ref.Name, ref.Namespace); err != nil {
 			return err
 		}
+	case KubeadmControlPlane:
+		kcp, err := getKubeadmControlPlane(proxy, ref.Name, ref.Namespace)
+		if err != nil || kcp == nil {
+			return errors.Wrapf(err, "failed to fetch %v/%v", ref.Kind, ref.Name)
+		}
+		if annotations.HasPaused(kcp.GetObjectMeta()) {
+			return errors.Errorf("can't restart paused KubeadmControlPlane (remove annotation 'cluster.x-k8s.io/paused' first): %v/%v", ref.Kind, ref.Name)
+		}
+		if err := setRolloutAfter(proxy, ref.Name, ref.Namespace); err != nil {
+			return err
+		}
 	default:
 		return errors.Errorf("Invalid resource type %v. Valid values: %v", ref.Kind, validResourceTypes)
 	}
@@ -53,3 +65,8 @@ func setRestartedAtAnnotation(proxy cluster.Proxy, name, namespace string) error
 	patch := client.RawPatch(types.MergePatchType, []byte(fmt.Sprintf("{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"cluster.x-k8s.io/restartedAt\":\"%v\"}}}}}", time.Now().Format(time.RFC3339))))
 	return patchMachineDeployment(proxy, name, namespace, patch)
 }
+
+func setRolloutAfter(proxy cluster.Proxy, name, namespace string) error {
+	patch := client.RawPatch(types.MergePatchType, []byte(fmt.Sprintf("{\"spec\":{\"rolloutAfter\":\"%v\"}}", time.Now().Format(time.RFC3339))))
+	return patchKubeadmControlPlane(proxy, name, namespace, patch)
+}