✨ Implement Init plugin subcommand

cmd/plugin/cmd/root.go

@@ -22,19 +22,26 @@ import (
 	"os"
 	"strings"
 
+	logf "sigs.k8s.io/cluster-api/cmd/clusterctl/log"
+	ctrl "sigs.k8s.io/controller-runtime"
+
 	"github.com/MakeNowJust/heredoc"
 	goerrors "github.com/go-errors/errors"
+	"github.com/go-logr/logr"
 	"github.com/spf13/cobra"
 )
 
 const (
 	groupDebug      = "group-debug"
 	groupManagement = "group-management"
 	groupOther      = "group-other"
+	latestVersion   = "latest"
 )
 
 var verbosity *int
 
+var log logr.Logger
+
 // RootCmd is capioperator root CLI command.
 var RootCmd = &cobra.Command{
 	Use:          "capioperator",
@@ -67,6 +74,10 @@ 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)
+	ctrl.SetLogger(log)
+
 	RootCmd.PersistentFlags().AddGoFlagSet(flag.CommandLine)
 
 	RootCmd.AddGroup(

cmd/plugin/cmd/suite_test.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2023 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 cmd
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"sigs.k8s.io/cluster-api-operator/internal/envtest"
+	ctrl "sigs.k8s.io/controller-runtime"
+)
+
+const (
+	waitShort = time.Second * 5
+	waitLong  = time.Second * 20
+)
+
+var (
+	env *envtest.Environment
+	ctx = ctrl.SetupSignalHandler()
+)
+
+func TestMain(m *testing.M) {
+	fmt.Println("Creating new test environment")
+
+	env = envtest.New()
+
+	go func() {
+		if err := env.Start(ctx); err != nil {
+			panic(fmt.Sprintf("Failed to start the envtest manager: %v", err))
+		}
+	}()
+	<-env.Manager.Elected()
+
+	// Run tests
+	code := m.Run()
+	// Tearing down the test environment
+	if err := env.Stop(); err != nil {
+		panic(fmt.Sprintf("Failed to stop the envtest: %v", err))
+	}
+
+	// Report exit code
+	os.Exit(code)
+}

cmd/plugin/cmd/utils.go

@@ -17,17 +17,32 @@ limitations under the License.
 package cmd
 
 import (
+	"context"
+	"errors"
 	"fmt"
+	"os"
 
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/tools/clientcmd"
+	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
 )
 
+var capiOperatorLabels = map[string]string{
+	"clusterctl.cluster.x-k8s.io/core": "capi-operator",
+	"control-plane":                    "controller-manager",
+}
+
+var ErrNotFound = fmt.Errorf("resource was not found")
+
 // CreateKubeClient creates a kubernetes client from provided kubeconfig and kubecontext.
 func CreateKubeClient(kubeconfigPath, kubeconfigContext string) (ctrlclient.Client, error) {
 	// Use specified kubeconfig path and context
@@ -51,3 +66,98 @@ func CreateKubeClient(kubeconfigPath, kubeconfigContext string) (ctrlclient.Clie
 
 	return client, nil
 }
+
+func EnsureNamespaceExists(ctx context.Context, client ctrlclient.Client, namespace string) error {
+	// Check if the namespace exists
+	ns := &corev1.Namespace{}
+
+	err := client.Get(ctx, ctrlclient.ObjectKey{Name: namespace}, ns)
+	if err == nil {
+		return nil
+	}
+
+	if !apierrors.IsNotFound(err) {
+		return fmt.Errorf("unexpected error during namespace checking: %w", err)
+	}
+
+	// Create the namespace if it doesn't exist
+	newNamespace := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: namespace,
+		},
+	}
+
+	if err := client.Create(ctx, newNamespace); err != nil {
+		return fmt.Errorf("unable to create namespace %s: %w", namespace, err)
+	}
+
+	return nil
+}
+
+// GetDeploymentByLabels fetches deployment based on the provided labels.
+func GetDeploymentByLabels(ctx context.Context, client ctrlclient.Client, labels map[string]string) (*appsv1.Deployment, error) {
+	var deploymentList appsv1.DeploymentList
+
+	// Search deployments with desired labels in all namespaces.
+	if err := client.List(ctx, &deploymentList, ctrlclient.MatchingLabels(labels)); err != nil {
+		return nil, fmt.Errorf("cannot get a list of deployments from the server: %w", err)
+	}
+
+	if len(deploymentList.Items) > 1 {
+		return nil, fmt.Errorf("more than one deployment found for given labels %v", labels)
+	}
+
+	if len(deploymentList.Items) == 0 {
+		return nil, ErrNotFound
+	}
+
+	return &deploymentList.Items[0], nil
+}
+
+// CheckDeploymentAvailability checks if the deployment with given labels is available.
+func CheckDeploymentAvailability(ctx context.Context, client ctrlclient.Client, labels map[string]string) (bool, error) {
+	deployment, err := GetDeploymentByLabels(ctx, client, labels)
+	if err != nil {
+		if errors.Is(err, ErrNotFound) {
+			return false, nil
+		}
+
+		return false, err
+	}
+
+	for _, cond := range deployment.Status.Conditions {
+		if cond.Type == appsv1.DeploymentAvailable && cond.Status == corev1.ConditionTrue {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+// GetKubeconfigLocation will read the environment variable $KUBECONFIG otherwise set it to ~/.kube/config.
+func GetKubeconfigLocation() string {
+	if kubeconfig := os.Getenv("KUBECONFIG"); kubeconfig != "" {
+		return kubeconfig
+	}
+
+	return clientcmd.RecommendedHomeFile
+}
+
+func NewGenericProvider(providerType clusterctlv1.ProviderType) operatorv1.GenericProvider {
+	switch providerType {
+	case clusterctlv1.CoreProviderType:
+		return &operatorv1.CoreProvider{}
+	case clusterctlv1.BootstrapProviderType:
+		return &operatorv1.BootstrapProvider{}
+	case clusterctlv1.ControlPlaneProviderType:
+		return &operatorv1.ControlPlaneProvider{}
+	case clusterctlv1.InfrastructureProviderType:
+		return &operatorv1.InfrastructureProvider{}
+	case clusterctlv1.AddonProviderType:
+		return &operatorv1.AddonProvider{}
+	case clusterctlv1.IPAMProviderType, clusterctlv1.RuntimeExtensionProviderType, clusterctlv1.ProviderTypeUnknown:
+		panic(fmt.Sprintf("unsupported provider type %s", providerType))
+	default:
+		panic(fmt.Sprintf("unknown provider type %s", providerType))
+	}
+}

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/MakeNowJust/heredoc v1.0.0
 	github.com/evanphx/json-patch/v5 v5.7.0
 	github.com/go-errors/errors v1.5.1
+	github.com/go-logr/logr v1.3.0
 	github.com/google/go-cmp v0.6.0
 	github.com/google/go-github/v52 v52.0.0
 	github.com/google/gofuzz v1.2.0
@@ -51,7 +52,6 @@ require (
 	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/go-logr/logr v1.3.0 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-openapi/jsonpointer v0.19.6 // indirect
 	github.com/go-openapi/jsonreference v0.20.2 // indirect

internal/controller/consts.go

@@ -23,9 +23,6 @@ const (
 	// if some preflight check has failed.
 	preflightFailedRequeueAfter = 30 * time.Second
 
-	httpsScheme             = "https"
-	githubDomain            = "github.com"
-	gitlabHostPrefix        = "gitlab."
-	gitlabPackagesAPIPrefix = "/api/v4/projects/"
-	configPath              = "/config/clusterctl.yaml"
+	// configPath is the path to the clusterctl config file.
+	configPath = "/config/clusterctl.yaml"
 )

internal/controller/manifests_downloader.go

@@ -26,10 +26,13 @@ import (
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
-	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-operator/util"
 )
 
 const (
@@ -76,7 +79,7 @@ func (p *phaseReconciler) downloadManifests(ctx context.Context) (reconcile.Resu
 
 	log.Info("Downloading provider manifests")
 
-	repo, err := repositoryFactory(ctx, p.providerConfig, p.configClient.Variables())
+	repo, err := util.RepositoryFactory(ctx, p.providerConfig, p.configClient.Variables())
 	if err != nil {
 		err = fmt.Errorf("failed to create repo from provider url for provider %q: %w", p.provider.GetName(), err)
 

internal/controller/phases.go

@@ -22,9 +22,7 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"net/url"
 	"os"
-	"strings"
 
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -554,42 +552,6 @@ func (p *phaseReconciler) newClusterClient() cluster.Client {
 	}))
 }
 
-// repositoryFactory returns the repository implementation corresponding to the provider URL.
-// inspired by https://github.com/kubernetes-sigs/cluster-api/blob/124d9be7035e492f027cdc7a701b6b179451190a/cmd/clusterctl/client/repository/client.go#L170
-func repositoryFactory(ctx context.Context, providerConfig configclient.Provider, configVariablesClient configclient.VariablesClient) (repository.Repository, error) {
-	// parse the repository url
-	rURL, err := url.Parse(providerConfig.URL())
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse repository url %q", providerConfig.URL())
-	}
-
-	if rURL.Scheme != httpsScheme {
-		return nil, fmt.Errorf("invalid provider url. there are no provider implementation for %q schema", rURL.Scheme)
-	}
-
-	// if the url is a GitHub repository
-	if rURL.Host == githubDomain {
-		repo, err := repository.NewGitHubRepository(ctx, providerConfig, configVariablesClient)
-		if err != nil {
-			return nil, fmt.Errorf("error creating the GitHub repository client: %w", err)
-		}
-
-		return repo, err
-	}
-
-	// if the url is a GitLab repository
-	if strings.HasPrefix(rURL.Host, gitlabHostPrefix) && strings.HasPrefix(rURL.Path, gitlabPackagesAPIPrefix) {
-		repo, err := repository.NewGitLabRepository(providerConfig, configVariablesClient)
-		if err != nil {
-			return nil, fmt.Errorf("error creating the GitLab repository client: %w", err)
-		}
-
-		return repo, err
-	}
-
-	return nil, fmt.Errorf("invalid provider url. Only GitHub and GitLab are supported for %q schema", rURL.Scheme)
-}
-
 func getLatestVersion(repoVersions []string) (string, error) {
 	if len(repoVersions) == 0 {
 		err := fmt.Errorf("no versions available")

internal/controller/phases_test.go

@@ -29,6 +29,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
 	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-operator/util"
 )
 
 func TestSecretReader(t *testing.T) {
@@ -475,7 +476,7 @@ func TestRepositoryFactory(t *testing.T) {
 			providerConfig, err := configClient.Providers().Get(providerName, providerType)
 			g.Expect(err).ToNot(HaveOccurred())
 
-			repo, err := repositoryFactory(ctx, providerConfig, configClient.Variables())
+			repo, err := util.RepositoryFactory(ctx, providerConfig, configClient.Variables())
 			if tc.expectedError {
 				g.Expect(err).To(HaveOccurred())
 

internal/envtest/environment.go

@@ -103,6 +103,8 @@ func New(uncachedObjs ...client.Object) *Environment {
 	root := path.Join(path.Dir(filename), "..", "..")
 	crdPaths := []string{
 		filepath.Join(root, "config", "crd", "bases"),
+		// cert-manager CRDs are stored there.
+		filepath.Join(root, "test", "testdata"),
 	}
 
 	if capiPath := getFilePathToClusterctlCRDs(root); capiPath != "" {