Get the latest operator version from the list of all available versions

Now we use "latest" tag, but due to recent clusterctl changes it forces
to download metadata.yaml file which is not available for CAPI operator.
Because of that installation fails with exceeded context deadline.

To prevent this we specify a version when we create a repo object, and
then pick the latest version from the list of all available versions.

Author: Fedosin

cmd/plugin/cmd/init.go

@@ -58,8 +58,10 @@ type initOptions struct {
 }
 
 const (
-	capiOperatorProviderName         = "capi-operator"
-	capiOperatorManifestsURLTemplate = "https://github.com/kubernetes-sigs/cluster-api-operator/releases/%s/operator-components.yaml"
+	capiOperatorProviderName = "capi-operator"
+	// We have to specify a version here, because if we set "latest", clusterctl libs will try to fetch metadata.yaml file for the latest
+	// release and fail since CAPI operator doesn't provide this file.
+	capiOperatorManifestsURL = "https://github.com/kubernetes-sigs/cluster-api-operator/releases/v0.1.0/operator-components.yaml"
 )
 
 var initOpts = &initOptions{}
@@ -383,8 +385,6 @@ func deployCAPIOperator(ctx context.Context, opts *initOptions) error {
 		return fmt.Errorf("cannot create config client: %w", err)
 	}
 
-	capiOperatorManifestsURL := fmt.Sprintf(capiOperatorManifestsURLTemplate, opts.operatorVersion)
-
 	providerConfig := configclient.NewProvider(capiOperatorProviderName, capiOperatorManifestsURL, clusterctlv1.ProviderTypeUnknown)
 
 	// Reduce waiting time for the repository creation from 30 seconds to 5.
@@ -397,7 +397,11 @@ func deployCAPIOperator(ctx context.Context, opts *initOptions) error {
 	}
 
 	if opts.operatorVersion == latestVersion {
-		opts.operatorVersion = repo.DefaultVersion()
+		// Detecting the latest release by sorting all available tags and picking that last one with release.
+		opts.operatorVersion, err = GetLatestRelease(ctx, repo)
+		if err != nil {
+			return fmt.Errorf("cannot get latest release: %w", err)
+		}
 
 		log.Info("Detected latest operator version", "Version", opts.operatorVersion)
 	}

cmd/plugin/cmd/utils.go

@@ -21,16 +21,19 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"sort"
 
 	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"
+	"k8s.io/apimachinery/pkg/util/version"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/tools/clientcmd"
 	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
+	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/repository"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	admissionv1 "k8s.io/api/admissionregistration/v1"
@@ -67,6 +70,8 @@ type genericProviderList interface {
 	operatorv1.GenericProviderList
 }
 
+var errNotFound = errors.New("404 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
@@ -181,3 +186,75 @@ func NewGenericProvider(providerType clusterctlv1.ProviderType) operatorv1.Gener
 		panic(fmt.Sprintf("unknown provider type %s", providerType))
 	}
 }
+
+// GetLatestRelease returns the latest patch release.
+func GetLatestRelease(ctx context.Context, repo repository.Repository) (string, error) {
+	versions, err := repo.GetVersions(ctx)
+	if err != nil {
+		return "", fmt.Errorf("failed to get repository versions: %w", err)
+	}
+
+	// Search for the latest release according to semantic version ordering.
+	// Releases with tag name that are not in semver format are ignored.
+	parsedReleaseVersions := []*version.Version{}
+
+	for _, v := range versions {
+		sv, err := version.ParseSemantic(v)
+		if err != nil {
+			// discard releases with tags that are not a valid semantic versions (the user can point explicitly to such releases)
+			continue
+		}
+
+		parsedReleaseVersions = append(parsedReleaseVersions, sv)
+	}
+
+	versionCandidates := parsedReleaseVersions
+
+	if len(parsedReleaseVersions) == 0 {
+		return "", errors.New("failed to find releases tagged with a valid semantic version number")
+	}
+
+	// Sort parsed versions by semantic version order.
+	sort.SliceStable(versionCandidates, func(i, j int) bool {
+		// Prioritize release versions over pre-releases. For example v1.0.0 > v2.0.0-alpha
+		// If both are pre-releases, sort by semantic version order as usual.
+		if versionCandidates[j].PreRelease() == "" && versionCandidates[i].PreRelease() != "" {
+			return false
+		}
+		if versionCandidates[i].PreRelease() == "" && versionCandidates[j].PreRelease() != "" {
+			return true
+		}
+
+		return versionCandidates[j].LessThan(versionCandidates[i])
+	})
+
+	// Limit the number of searchable versions by 3.
+	size := 3
+	if size > len(versionCandidates) {
+		size = len(versionCandidates)
+	}
+
+	versionCandidates = versionCandidates[:size]
+
+	for _, v := range versionCandidates {
+		// Iterate through sorted versions and try to fetch a file from that release.
+		// If it's completed successfully, we get the latest release.
+		// Note: the fetched file will be cached and next time we will get it from the cache.
+		versionString := "v" + v.String()
+
+		_, err := repo.GetFile(ctx, versionString, repo.ComponentsPath())
+		if err != nil {
+			if errors.Is(err, errNotFound) {
+				// Ignore this version
+				continue
+			}
+
+			return "", err
+		}
+
+		return versionString, nil
+	}
+
+	// If we reached this point, it means we didn't find any release.
+	return "", errors.New("failed to find releases tagged with a valid semantic version number")
+}