Add logging

Author: Fedosin

cmd/plugin/cmd/init.go

@@ -22,11 +22,14 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"github.com/spf13/cobra"
 
 	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/util/wait"
 	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/cluster"
 	configclient "sigs.k8s.io/cluster-api/cmd/clusterctl/client/config"
@@ -123,13 +126,13 @@ func init() {
 		"Context to be used within the kubeconfig file. If empty, current context will be used.")
 	initCmd.PersistentFlags().StringVar(&initOpts.operatorVersion, "operator-version", "",
 		"CAPI Operator version (e.g. v0.7.0) to install on the management cluster. If unspecified, the latest release is used.")
-	initCmd.PersistentFlags().StringVar(&initOpts.coreProvider, "core", "cluster-api",
+	initCmd.PersistentFlags().StringVar(&initOpts.coreProvider, "core", "",
 		"Core provider version (e.g. cluster-api:v1.1.5) to add to the management cluster. If unspecified, Cluster API's latest release is used.")
 	initCmd.PersistentFlags().StringSliceVarP(&initOpts.infrastructureProviders, "infrastructure", "i", []string{},
 		"Infrastructure providers and versions (e.g. aws:v0.5.0) to add to the management cluster.")
-	initCmd.PersistentFlags().StringSliceVarP(&initOpts.bootstrapProviders, "bootstrap", "b", []string{"kubeadm"},
+	initCmd.PersistentFlags().StringSliceVarP(&initOpts.bootstrapProviders, "bootstrap", "b", []string{},
 		"Bootstrap providers and versions (e.g. kubeadm:v1.1.5) to add to the management cluster. If unspecified, Kubeadm bootstrap provider's latest release is used.")
-	initCmd.PersistentFlags().StringSliceVarP(&initOpts.controlPlaneProviders, "control-plane", "c", []string{"kubeadm"},
+	initCmd.PersistentFlags().StringSliceVarP(&initOpts.controlPlaneProviders, "control-plane", "c", []string{},
 		"Control plane providers and versions (e.g. kubeadm:v1.1.5) to add to the management cluster. If unspecified, the Kubeadm control plane provider's latest release is used.")
 	// initCmd.PersistentFlags().StringSliceVar(&initOpts.ipamProviders, "ipam", nil,
 	//	"IPAM providers and versions (e.g. infoblox:v0.0.1) to add to the management cluster.")
@@ -157,8 +160,16 @@ func runInit() error {
 		return fmt.Errorf("cannot create a client: %w", err)
 	}
 
-	// Checking if CAPI operator deployment exists.
-	deploymentExists, err := checkCAPIOpearatorAvailability(ctx, client)
+	log.Info("Checking that Cert Manager is installed and running.")
+
+	// Ensure that cert manager is installed.
+	if err := ensureCertManager(initOpts); err != nil {
+		return fmt.Errorf("cannot ensure that cert manager is installed: %w", err)
+	}
+
+	log.Info("Checking that CAPI Operator is installed and running.")
+
+	deploymentExists, err := checkCAPIOperatorAvailability(ctx, client)
 	if err != nil {
 		return fmt.Errorf("cannot check CAPI operator availability: %w", err)
 	}
@@ -167,16 +178,32 @@ func runInit() error {
 		return fmt.Errorf("cannot specify an operator version when the CAPI operator is already installed")
 	}
 
-	// Ensure that cert manager is installed.
-	if err := ensureCertManager(initOpts); err != nil {
-		return fmt.Errorf("cannot ensure that cert manager is installed: %w", err)
-	}
-
 	// Deploy CAPI operator if it doesn't exist.
 	if !deploymentExists {
+		log.Info("Installing CAPI operator", "Version", initOpts.operatorVersion)
+
 		if err := deployCAPIOperator(initOpts); err != nil {
 			return fmt.Errorf("cannot deploy CAPI operator: %w", err)
 		}
+
+		opts := wait.Backoff{
+			Duration: 500 * time.Millisecond,
+			Factor:   1.5,
+			Steps:    10,
+			Jitter:   0.4,
+		}
+
+		log.Info("Waiting for CAPI Operator to be available...")
+
+		if err := wait.ExponentialBackoff(opts, func() (bool, error) {
+			return checkCAPIOperatorAvailability(ctx, client)
+		}); err != nil {
+			return fmt.Errorf("cannot check CAPI operator availability: %w", err)
+		}
+
+		log.Info("CAPI Operator is successfully installed.")
+	} else {
+		log.Info("Skipping installing CAPI Operator as it is already installed.")
 	}
 
 	return initProviders(ctx, client, initOpts)
@@ -221,8 +248,8 @@ func initProviders(ctx context.Context, client ctrlclient.Client, initOpts *init
 	return nil
 }
 
-// checkCAPIOpearatorAvailability checks if the CAPI operator is available on the management cluster.
-func checkCAPIOpearatorAvailability(ctx context.Context, client ctrlclient.Client) (bool, error) {
+// checkCAPIOperatorAvailability checks if the CAPI operator is available on the management cluster.
+func checkCAPIOperatorAvailability(ctx context.Context, client ctrlclient.Client) (bool, error) {
 	var deploymentList appsv1.DeploymentList
 
 	// Search deployments with desired labels in all namespaces.
@@ -234,7 +261,19 @@ func checkCAPIOpearatorAvailability(ctx context.Context, client ctrlclient.Clien
 		return false, fmt.Errorf("more than one CAPI Operator deployments were found")
 	}
 
-	return len(deploymentList.Items) == 1, nil
+	if len(deploymentList.Items) == 0 {
+		return false, nil
+	}
+
+	deployment := deploymentList.Items[0]
+
+	for _, cond := range deployment.Status.Conditions {
+		if cond.Type == appsv1.DeploymentAvailable && cond.Status == corev1.ConditionTrue {
+			return true, nil
+		}
+	}
+
+	return false, nil
 }
 
 func ensureCertManager(opts *initOptions) error {
@@ -378,16 +417,24 @@ func createGenericProvider(ctx context.Context, client ctrlclient.Client, provid
 		spec := provider.GetSpec()
 		spec.Version = version
 		provider.SetSpec(spec)
+	} else {
+		version = "latest"
 	}
 
 	// Ensure that desired namespace exists
 	if err := EnsureNamespaceExists(ctx, client, namespace); err != nil {
 		return fmt.Errorf("cannot ensure that namespace exists: %w", err)
 	}
 
+	log.Info("Installing provider", "Type", provider.GetType(), "Name", name, "Version", version, "Namespace", namespace)
+
 	// Create the provider
-	if err := client.Create(ctx, provider.GetObject()); err != nil && !apierrors.IsAlreadyExists(err) {
-		return fmt.Errorf("cannot create provider: %w", err)
+	if err := client.Create(ctx, provider.GetObject()); err != nil {
+		if !apierrors.IsAlreadyExists(err) {
+			return fmt.Errorf("cannot create provider: %w", err)
+		}
+
+		log.Info("Provider already exists, skipping creation", "Type", provider.GetType(), "Name", name, "Version", version, "Namespace", namespace)
 	}
 
 	return nil

cmd/plugin/cmd/init_test.go

@@ -71,6 +71,27 @@ func TestCheckCAPIOpearatorAvailability(t *testing.T) {
 
 				g.Expect(env.Create(ctx, deployment)).To(Succeed())
 
+				// Get created deployment and update its status
+				g.Eventually(func() (bool, error) {
+					err := env.Get(ctx, ctrlclient.ObjectKeyFromObject(deployment), deployment)
+					if err != nil {
+						return false, err
+					}
+
+					return deployment != nil, nil
+				}, waitShort).Should(BeTrue())
+
+				deployment.Status.Conditions = []appsv1.DeploymentCondition{
+					{
+						Type:    appsv1.DeploymentAvailable,
+						Status:  corev1.ConditionTrue,
+						Reason:  "MinimumReplicasAvailable",
+						Message: "Deployment has minimum availability.",
+					},
+				}
+
+				g.Expect(env.Status().Update(ctx, deployment)).To(Succeed())
+
 				g.Eventually(func() (bool, error) {
 					deploymentFromServer := &appsv1.Deployment{}
 					err := env.Get(ctx, ctrlclient.ObjectKeyFromObject(deployment), deploymentFromServer)
@@ -123,7 +144,7 @@ func TestCheckCAPIOpearatorAvailability(t *testing.T) {
 				resources = append(resources, deploymentClone)
 			}
 
-			available, err := checkCAPIOpearatorAvailability(ctx, env.Client)
+			available, err := checkCAPIOperatorAvailability(ctx, env.Client)
 
 			if tt.wantErr {
 				g.Expect(err).To(HaveOccurred())

cmd/plugin/cmd/root.go

@@ -22,8 +22,11 @@ import (
 	"os"
 	"strings"
 
+	logf "sigs.k8s.io/cluster-api/cmd/clusterctl/log"
+
 	"github.com/MakeNowJust/heredoc"
 	goerrors "github.com/go-errors/errors"
+	"github.com/go-logr/logr"
 	"github.com/spf13/cobra"
 )
 
@@ -35,6 +38,8 @@ const (
 
 var verbosity *int
 
+var log logr.Logger
+
 // RootCmd is capioperator root CLI command.
 var RootCmd = &cobra.Command{
 	Use:          "capioperator",
@@ -67,6 +72,9 @@ func init() {
 
 	verbosity = flag.CommandLine.Int("v", 0, "Set the log level verbosity. This overrides the CAPIOPERATOR_LOG_LEVEL environment variable.")
 
+	log = logf.NewLogger(logf.WithThreshold(verbosity))
+	logf.SetLogger(log)
+
 	RootCmd.PersistentFlags().AddGoFlagSet(flag.CommandLine)
 
 	RootCmd.AddGroup(

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/MakeNowJust/heredoc v1.0.0
 	github.com/evanphx/json-patch/v5 v5.6.0
 	github.com/go-errors/errors v1.4.2
+	github.com/go-logr/logr v1.2.4
 	github.com/google/go-cmp v0.6.0
 	github.com/google/go-github/v52 v52.0.0
 	github.com/google/gofuzz v1.2.0
@@ -48,7 +49,6 @@ require (
 	github.com/emicklei/go-restful/v3 v3.10.2 // indirect
 	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/go-logr/logr v1.2.4 // indirect
 	github.com/go-openapi/jsonpointer v0.19.6 // indirect
 	github.com/go-openapi/jsonreference v0.20.1 // indirect
 	github.com/go-openapi/swag v0.22.3 // indirect