Generate Controlplane Init Bootstrap data

This PR generates the `kubeadm init` bootstrap data

Signed-off-by: Chuck Ha <[email protected]>

Author: chuckha

cloudinit/controlplane_certs.go

@@ -16,7 +16,7 @@ limitations under the License.
 
 package cloudinit
 
-import "errors"
+import "github.com/pkg/errors"
 
 // Certificates is a template struct to hold certificate data
 type Certificates struct {

cloudinit/controlplane_init.go

@@ -16,10 +16,6 @@ limitations under the License.
 
 package cloudinit
 
-import (
-	"github.com/pkg/errors"
-)
-
 const (
 	controlPlaneCloudInit = `{{.Header}}
 {{template "files" .WriteFiles}}
@@ -50,15 +46,15 @@ type ControlPlaneInput struct {
 func NewInitControlPlane(input *ControlPlaneInput) (string, error) {
 	input.Header = cloudConfigHeader
 	if err := input.Certificates.validate(); err != nil {
-		return "", errors.Wrapf(err, "ControlPlaneInput is invalid")
+		return "", err
 	}
 
 	input.WriteFiles = certificatesToFiles(input.Certificates)
 	input.WriteFiles = append(input.WriteFiles, input.AdditionalFiles...)
 	userData, err := generate("InitControlplane", controlPlaneCloudInit, input)
 	if err != nil {
-		return "", errors.Wrapf(err, "failed to generate user data for new control plane machine")
+		return "", err
 	}
 
-	return userData, err
+	return userData, nil
 }

controllers/bootstrapdata.go

@@ -0,0 +1,67 @@
+/*
+Copyright 2019 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 controllers
+
+import (
+	"encoding/json"
+
+	"github.com/go-logr/logr"
+	"github.com/pkg/errors"
+	"sigs.k8s.io/cluster-api-bootstrap-provider-kubeadm/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-bootstrap-provider-kubeadm/cloudinit"
+)
+
+// BootstrapDataGenerator is responsible for generating bootstrap data for a given config
+type BootstrapDataGenerator struct {
+	logr.Logger
+}
+
+// GenerateControlPlaneInit will generate the bootstrap data and set the fields necessary on the config object.
+func (u *BootstrapDataGenerator) GenerateControlPlaneInit(config *v1alpha2.KubeadmConfig) error {
+	u.Info("Generating user data for first control plane")
+
+	// TODO: use secrets for certs, plug into kubeadm
+	// TODO: sub in things in the cluster configuration like the cluster name and other data we can extract from the cluster object
+	config.Spec.ClusterConfiguration.APIVersion = "v1beta1"
+	config.Spec.ClusterConfiguration.Kind = "ClusterConfiguration"
+	clusterdata, err := json.Marshal(config.Spec.ClusterConfiguration)
+	if err != nil {
+		u.Error(err, "failed to marshal cluster configuration")
+		return errors.WithStack(err)
+	}
+
+	config.Spec.ClusterConfiguration.Kind = "v1beta1"
+	config.Spec.ClusterConfiguration.APIVersion = "InitConfiguration"
+	initdata, err := json.Marshal(config.Spec.InitConfiguration)
+	if err != nil {
+		u.Error(err, "failed to marshal init configuration")
+		return errors.WithStack(err)
+	}
+
+	cicfg, err := cloudinit.NewInitControlPlane(&cloudinit.ControlPlaneInput{
+		ClusterConfiguration: string(clusterdata),
+		InitConfiguration:    string(initdata),
+	})
+	if err != nil {
+		u.Error(err, "could not create new init control plane")
+		return err
+	}
+
+	config.Status.BootstrapData = []byte(cicfg)
+	config.Status.Ready = true
+	return nil
+}

controllers/kubeadmconfig_controller.go

@@ -25,6 +25,7 @@ import (
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	kubeadmv1alpha2 "sigs.k8s.io/cluster-api-bootstrap-provider-kubeadm/api/v1alpha2"
 	"sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha2"
+	"sigs.k8s.io/cluster-api/pkg/util"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -33,10 +34,23 @@ var (
 	machineKind = v1alpha2.SchemeGroupVersion.WithKind("Machine")
 )
 
+
+// Locker are the methods necessary to add locking around the first control plane init.
+type Locker interface {
+	Acquire(*v1alpha2.Cluster) bool
+	Release(*v1alpha2.Cluster) bool
+}
+
+type bootstrapDataGenerator interface {
+	GenerateControlPlaneInit(config *kubeadmv1alpha2.KubeadmConfig) error
+}
+
 // KubeadmConfigReconciler reconciles a KubeadmConfig object
 type KubeadmConfigReconciler struct {
 	client.Client
-	Log logr.Logger
+	ControlPlaneInitLock   Locker
+	Log                    logr.Logger
+	BootstrapDataGenerator bootstrapDataGenerator
 }
 
 // +kubebuilder:rbac:groups=bootstrap.cluster.x-k8s.io,resources=kubeadmconfigs,verbs=get;list;watch;create;update;patch;delete
@@ -108,16 +122,29 @@ func (r *KubeadmConfigReconciler) Reconcile(req ctrl.Request) (ctrl.Result, erro
 		return ctrl.Result{}, err
 	}
 
-	// maybe do something with cluster some day
-	// maybe do something interesting here some day
-	config.Status.BootstrapData = []byte("hello world")
-	config.Status.Ready = true
+	// Generate the cloud-init for controlplane init
+	if r.BootstrapDataGenerator == nil {
+		r.BootstrapDataGenerator = &BootstrapDataGenerator{
+			Logger: r.Log.WithName("user-data-generator"),
+		}
+	}
+
+	if util.IsControlPlaneMachine(machine) {
+		locked := r.ControlPlaneInitLock.Acquire(cluster)
+		if locked {
+			// Generate control plane init
+			if err := r.BootstrapDataGenerator.GenerateControlPlaneInit(&config); err != nil {
+				log.Error(err, "error generating control plane init")
+				return ctrl.Result{}, err
+			}
+		}
+
+	}
 
 	if err := r.Update(ctx, &config); err != nil {
 		log.Error(err, "failed to update config")
 		return ctrl.Result{}, err
 	}
-	log.Info("Updated config with bootstrap data")
 	return ctrl.Result{}, nil
 }
 

controllers/control_plane_init_locker.go renamed to locker/control_plane_init_locker.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package controllers
+package locker
 
 import (
 	"fmt"
@@ -27,28 +27,15 @@ import (
 	clusterv2 "sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha2"
 )
 
-// ControlPlaneInitLocker provides a locking mechanism for cluster initialization.
-type ControlPlaneInitLocker interface {
-	// Acquire returns true if it acquires the lock for the cluster.
-	Acquire(cluster *clusterv2.Cluster) bool
-}
-
-// controlPlaneInitLocker uses a ConfigMap to synchronize cluster initialization.
-type controlPlaneInitLocker struct {
+// ControlPlaneInitLocker uses a ConfigMap to synchronize cluster initialization.
+type ControlPlaneInitLocker struct {
 	log             logr.Logger
 	configMapClient corev1.ConfigMapsGetter
 }
 
-var _ ControlPlaneInitLocker = &controlPlaneInitLocker{}
-
-func newControlPlaneInitLocker(log logr.Logger, configMapClient corev1.ConfigMapsGetter) *controlPlaneInitLocker {
-	return &controlPlaneInitLocker{
-		log:             log,
-		configMapClient: configMapClient,
-	}
-}
-
-func (l *controlPlaneInitLocker) Acquire(cluster *clusterv2.Cluster) bool {
+// Acquire will attempt to acquire a lock that guarantees this is the first control plane to be created.
+// TODO Consider adding a short circuit if there is already a control plane node to reduce the calls to the API server.
+func (l *ControlPlaneInitLocker) Acquire(cluster *clusterv2.Cluster) bool {
 	configMapName := fmt.Sprintf("%s-controlplane", cluster.UID)
 	log := l.log.WithValues("namespace", cluster.Namespace, "cluster-name", cluster.Name, "configmap-name", configMapName)
 
@@ -94,7 +81,8 @@ func (l *controlPlaneInitLocker) Acquire(cluster *clusterv2.Cluster) bool {
 	return true
 }
 
-func (l *controlPlaneInitLocker) Release(cluster *clusterv2.Cluster) bool {
+// Release releases the lock for someone else to get.
+func (l *ControlPlaneInitLocker) Release(cluster *clusterv2.Cluster) bool {
 	configMapName := fmt.Sprintf("%s-controlplane", cluster.UID)
 	log := l.log.WithValues("namespace", cluster.Namespace, "cluster-name", cluster.Name, "configmap-name", configMapName)
 
@@ -116,7 +104,7 @@ func (l *controlPlaneInitLocker) Release(cluster *clusterv2.Cluster) bool {
 	return true
 }
 
-func (l *controlPlaneInitLocker) configMapExists(namespace, name string) (bool, error) {
+func (l *ControlPlaneInitLocker) configMapExists(namespace, name string) (bool, error) {
 	_, err := l.configMapClient.ConfigMaps(namespace).Get(name, metav1.GetOptions{})
 	if apierrors.IsNotFound(err) {
 		return false, nil

controllers/control_plane_init_locker_test.go renamed to locker/control_plane_init_locker_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package controllers
+package locker
 
 import (
 	"testing"
@@ -64,7 +64,7 @@ func TestControlPlaneInitLockerAcquire(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			l := &controlPlaneInitLocker{
+			l := &ControlPlaneInitLocker{
 				log: log.ZapLogger(true),
 				configMapClient: &configMapsGetter{
 					configMap:   tc.configMap,
@@ -120,7 +120,7 @@ func TestControlPlaneInitLockerRelease(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			l := &controlPlaneInitLocker{
+			l := &ControlPlaneInitLocker{
 				log: log.ZapLogger(true),
 				configMapClient: &configMapsGetter{
 					configMap:   tc.configMap,