Merge pull request #4866 from CecileRobertMichon/clusterctl-older-api-main

🐛 Use metadata.yaml in github repo to fetch latest release for older contracts

Author: k8s-ci-robot

cmd/clusterctl/api/v1alpha3/metadata_type.go

@@ -60,3 +60,14 @@ func (m *Metadata) GetReleaseSeriesForVersion(version *version.Version) *Release
 
 	return nil
 }
+
+// GetReleaseSeriesForContract returns the release series for a given API Version, e.g. `v1alpha4`.
+func (m *Metadata) GetReleaseSeriesForContract(contract string) *ReleaseSeries {
+	for _, releaseSeries := range m.ReleaseSeries {
+		if contract == releaseSeries.Contract {
+			return &releaseSeries
+		}
+	}
+
+	return nil
+}

cmd/clusterctl/client/cluster/installer.go

@@ -174,7 +174,7 @@ func (i *providerInstaller) getProviderContract(providerInstanceContracts map[st
 	}
 
 	if releaseSeries.Contract != clusterv1.GroupVersion.Version {
-		return "", errors.Errorf("current version of clusterctl could install only %s providers, detected %s for provider %s", clusterv1.GroupVersion.Version, releaseSeries.Contract, provider.ManifestLabel())
+		return "", errors.Errorf("current version of clusterctl is only compatible with %s providers, detected %s for provider %s", clusterv1.GroupVersion.Version, releaseSeries.Contract, provider.ManifestLabel())
 	}
 
 	providerInstanceContracts[provider.InstanceName()] = releaseSeries.Contract

cmd/clusterctl/client/repository/metadata_client.go

@@ -26,6 +26,8 @@ import (
 	logf "sigs.k8s.io/cluster-api/cmd/clusterctl/log"
 )
 
+const metadataFile = "metadata.yaml"
+
 // MetadataClient has methods to work with metadata hosted on a provider repository.
 // Metadata are yaml files providing additional information about provider's assets like e.g the version compatibility Matrix.
 type MetadataClient interface {
@@ -59,33 +61,32 @@ func (f *metadataClient) Get() (*clusterctlv1.Metadata, error) {
 
 	// gets the metadata file from the repository
 	version := f.version
-	name := "metadata.yaml"
 
 	file, err := getLocalOverride(&newOverrideInput{
 		configVariablesClient: f.configVarClient,
 		provider:              f.provider,
 		version:               version,
-		filePath:              name,
+		filePath:              metadataFile,
 	})
 	if err != nil {
 		return nil, err
 	}
 	if file == nil {
-		log.V(5).Info("Fetching", "File", name, "Provider", f.provider.Name(), "Type", f.provider.Type(), "Version", version)
-		file, err = f.repository.GetFile(version, name)
+		log.V(5).Info("Fetching", "File", metadataFile, "Provider", f.provider.Name(), "Type", f.provider.Type(), "Version", version)
+		file, err = f.repository.GetFile(version, metadataFile)
 		if err != nil {
-			return nil, errors.Wrapf(err, "failed to read %q from the repository for provider %q", name, f.provider.ManifestLabel())
+			return nil, errors.Wrapf(err, "failed to read %q from the repository for provider %q", metadataFile, f.provider.ManifestLabel())
 		}
 	} else {
-		log.V(1).Info("Using", "Override", name, "Provider", f.provider.ManifestLabel(), "Version", version)
+		log.V(1).Info("Using", "Override", metadataFile, "Provider", f.provider.ManifestLabel(), "Version", version)
 	}
 
 	// Convert the yaml into a typed object
 	obj := &clusterctlv1.Metadata{}
 	codecFactory := serializer.NewCodecFactory(scheme.Scheme)
 
 	if err := runtime.DecodeInto(codecFactory.UniversalDecoder(), file, obj); err != nil {
-		return nil, errors.Wrapf(err, "error decoding %q for provider %q", name, f.provider.ManifestLabel())
+		return nil, errors.Wrapf(err, "error decoding %q for provider %q", metadataFile, f.provider.ManifestLabel())
 	}
 
 	//TODO: consider if to add metadata validation (TBD)

cmd/clusterctl/client/repository/repository_github.go

@@ -25,6 +25,13 @@ import (
 	"path/filepath"
 	"strings"
 
+	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	clusterv1 "sigs.k8s.io/cluster-api/api/v1alpha4"
+	"sigs.k8s.io/cluster-api/cmd/clusterctl/internal/scheme"
+
 	"github.com/google/go-github/v33/github"
 	"github.com/pkg/errors"
 	"golang.org/x/oauth2"
@@ -171,7 +178,7 @@ func newGitHubRepository(providerConfig config.Provider, configVariablesClient c
 	}
 
 	if defaultVersion == githubLatestReleaseLabel {
-		repo.defaultVersion, err = repo.getLatestRelease()
+		repo.defaultVersion, err = repo.getLatestContractRelease(clusterv1.GroupVersion.Version)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to get GitHub latest version")
 		}
@@ -238,9 +245,53 @@ func (g *gitHubRepository) getVersions() ([]string, error) {
 	return versions, nil
 }
 
+// getLatestContractRelease returns the latest patch release for a github repository for the current API contract, according to
+// semantic version order of the release tag name.
+func (g *gitHubRepository) getLatestContractRelease(contract string) (string, error) {
+	latest, err := g.getLatestRelease()
+	if err != nil {
+		return latest, err
+	}
+	// Attempt to check if the latest release satisfies the API Contract
+	// This is a best-effort attempt to find the latest release for an older API contract if it's not the latest Github release.
+	// If an error occurs, we just return the latest release.
+	file, err := g.GetFile(latest, metadataFile)
+	if err != nil {
+		// if we can't get the metadata file from the release, we return latest.
+		return latest, nil // nolint:nilerr
+	}
+	latestMetadata := &clusterctlv1.Metadata{}
+	codecFactory := serializer.NewCodecFactory(scheme.Scheme)
+	if err := runtime.DecodeInto(codecFactory.UniversalDecoder(), file, latestMetadata); err != nil {
+		return latest, nil // nolint:nilerr
+	}
+
+	releaseSeries := latestMetadata.GetReleaseSeriesForContract(contract)
+	if releaseSeries == nil {
+		return latest, nil
+	}
+
+	sv, err := version.ParseSemantic(latest)
+	if err != nil {
+		return latest, nil // nolint:nilerr
+	}
+
+	// If the Major or Minor version of the latest release doesn't match the release series for the current contract,
+	// return the latest patch release of the desired Major/Minor version.
+	if sv.Major() != releaseSeries.Major || sv.Minor() != releaseSeries.Minor {
+		return g.getLatestPatchRelease(&releaseSeries.Major, &releaseSeries.Minor)
+	}
+	return latest, nil
+}
+
 // getLatestRelease returns the latest release for a github repository, according to
 // semantic version order of the release tag name.
 func (g *gitHubRepository) getLatestRelease() (string, error) {
+	return g.getLatestPatchRelease(nil, nil)
+}
+
+// getLatestRelease returns the latest patch release for a given Major and Minor version.
+func (g *gitHubRepository) getLatestPatchRelease(major, minor *uint) (string, error) {
 	versions, err := g.getVersions()
 	if err != nil {
 		return "", g.handleGithubErr(err, "failed to get the list of versions")
@@ -261,6 +312,11 @@ func (g *gitHubRepository) getLatestRelease() (string, error) {
 			continue
 		}
 
+		if (major != nil && sv.Major() != *major) || (minor != nil && sv.Minor() != *minor) {
+			// skip versions that don't match the desired Major.Minor version.
+			continue
+		}
+
 		// track prereleases separately
 		if sv.PreRelease() != "" {
 			if latestPrereleaseVersion == nil || latestPrereleaseVersion.LessThan(sv) {

cmd/clusterctl/client/repository/repository_github_test.go

@@ -283,6 +283,93 @@ func Test_gitHubRepository_getVersions(t *testing.T) {
 	}
 }
 
+func Test_gitHubRepository_getLatestContractRelease(t *testing.T) {
+	client, mux, teardown := test.NewFakeGitHub()
+	defer teardown()
+
+	// setup an handler for returning 3 fake releases
+	mux.HandleFunc("/repos/o/r1/releases", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `[`)
+		fmt.Fprint(w, `{"id":1, "tag_name": "v0.4.0", "assets": [{"id": 1, "name": "metadata.yaml"}]},`)
+		fmt.Fprint(w, `{"id":2, "tag_name": "v0.3.2", "assets": [{"id": 1, "name": "metadata.yaml"}]},`)
+		fmt.Fprint(w, `{"id":3, "tag_name": "v0.3.1", "assets": [{"id": 1, "name": "metadata.yaml"}]}`)
+		fmt.Fprint(w, `]`)
+	})
+
+	// test.NewFakeGitHub and handler for returning a fake release
+	mux.HandleFunc("/repos/o/r1/releases/tags/v0.4.0", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{"id":13, "tag_name": "v0.4.0", "assets": [{"id": 1, "name": "metadata.yaml"}] }`)
+	})
+
+	// test.NewFakeGitHub an handler for returning a fake release metadata file
+	mux.HandleFunc("/repos/o/r1/releases/assets/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		w.Header().Set("Content-Type", "application/octet-stream")
+		w.Header().Set("Content-Disposition", "attachment; filename=metadata.yaml")
+		fmt.Fprint(w, "apiVersion: clusterctl.cluster.x-k8s.io/v1alpha3\nreleaseSeries:\n  - major: 0\n    minor: 4\n    contract: v1alpha4\n  - major: 0\n    minor: 3\n    contract: v1alpha3\n")
+	})
+
+	configVariablesClient := test.NewFakeVariableClient()
+
+	type field struct {
+		providerConfig config.Provider
+	}
+	tests := []struct {
+		name     string
+		field    field
+		contract string
+		want     string
+		wantErr  bool
+	}{
+		{
+			name: "Get latest release if it matches the contract",
+			field: field{
+				providerConfig: config.NewProvider("test", "https://github.com/o/r1/releases/latest/path", clusterctlv1.CoreProviderType),
+			},
+			contract: "v1alpha4",
+			want:     "v0.4.0",
+			wantErr:  false,
+		},
+		{
+			name: "Get previous release if the latest doesn't match the contract",
+			field: field{
+				providerConfig: config.NewProvider("test", "https://github.com/o/r1/releases/latest/path", clusterctlv1.CoreProviderType),
+			},
+			contract: "v1alpha3",
+			want:     "v0.3.2",
+			wantErr:  false,
+		},
+		{
+			name: "Return the latest release if the contract doesn't exist",
+			field: field{
+				providerConfig: config.NewProvider("test", "https://github.com/o/r1/releases/latest/path", clusterctlv1.CoreProviderType),
+			},
+			want:     "v0.4.0",
+			contract: "foo",
+			wantErr:  false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+			resetCaches()
+
+			gRepo, err := newGitHubRepository(tt.field.providerConfig, configVariablesClient, injectGithubClient(client))
+			g.Expect(err).NotTo(HaveOccurred())
+
+			got, err := gRepo.getLatestContractRelease(tt.contract)
+			if tt.wantErr {
+				g.Expect(err).To(HaveOccurred())
+				return
+			}
+			g.Expect(err).NotTo(HaveOccurred())
+			g.Expect(got).To(Equal(tt.want))
+		})
+	}
+}
+
 func Test_gitHubRepository_getLatestRelease(t *testing.T) {
 	client, mux, teardown := test.NewFakeGitHub()
 	defer teardown()
@@ -370,6 +457,87 @@ func Test_gitHubRepository_getLatestRelease(t *testing.T) {
 	}
 }
 
+func Test_gitHubRepository_getLatestPatchRelease(t *testing.T) {
+	client, mux, teardown := test.NewFakeGitHub()
+	defer teardown()
+
+	// setup an handler for returning 3 fake releases
+	mux.HandleFunc("/repos/o/r1/releases", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `[`)
+		fmt.Fprint(w, `{"id":1, "tag_name": "v0.4.0"},`)
+		fmt.Fprint(w, `{"id":2, "tag_name": "v0.3.2"},`)
+		fmt.Fprint(w, `{"id":3, "tag_name": "v1.3.2"}`)
+		fmt.Fprint(w, `]`)
+	})
+
+	major0 := uint(0)
+	minor3 := uint(3)
+	minor4 := uint(4)
+
+	configVariablesClient := test.NewFakeVariableClient()
+
+	type field struct {
+		providerConfig config.Provider
+	}
+	tests := []struct {
+		name    string
+		field   field
+		major   *uint
+		minor   *uint
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "Get latest patch release, no Major/Minor specified",
+			field: field{
+				providerConfig: config.NewProvider("test", "https://github.com/o/r1/releases/latest/path", clusterctlv1.CoreProviderType),
+			},
+			minor:   nil,
+			major:   nil,
+			want:    "v1.3.2",
+			wantErr: false,
+		},
+		{
+			name: "Get latest patch release, for Major 0 and Minor 3",
+			field: field{
+				providerConfig: config.NewProvider("test", "https://github.com/o/r1/releases/latest/path", clusterctlv1.CoreProviderType),
+			},
+			major:   &major0,
+			minor:   &minor3,
+			want:    "v0.3.2",
+			wantErr: false,
+		},
+		{
+			name: "Get latest patch release, for Major 0 and Minor 4",
+			field: field{
+				providerConfig: config.NewProvider("test", "https://github.com/o/r1/releases/latest/path", clusterctlv1.CoreProviderType),
+			},
+			major:   &major0,
+			minor:   &minor4,
+			want:    "v0.4.0",
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+			resetCaches()
+
+			gRepo, err := newGitHubRepository(tt.field.providerConfig, configVariablesClient, injectGithubClient(client))
+			g.Expect(err).NotTo(HaveOccurred())
+
+			got, err := gRepo.getLatestPatchRelease(tt.major, tt.minor)
+			if tt.wantErr {
+				g.Expect(err).To(HaveOccurred())
+				return
+			}
+			g.Expect(err).NotTo(HaveOccurred())
+			g.Expect(got).To(Equal(tt.want))
+		})
+	}
+}
+
 func Test_gitHubRepository_getReleaseByTag(t *testing.T) {
 	client, mux, teardown := test.NewFakeGitHub()
 	defer teardown()