Added getLatestRelease() to fetch the latest release.

Added unit-tests for latest release logic.

Author: Arvinderpal

cmd/clusterctl/pkg/client/repository/repository_local_unix.go

@@ -18,11 +18,13 @@ package repository
 
 import (
 	"io/ioutil"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/pkg/errors"
+	"k8s.io/apimachinery/pkg/util/version"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/pkg/client/config"
 )
 
@@ -33,6 +35,10 @@ import (
 // specific data must adhere to the following layout:
 // {basepath}/{owner}/{provider-name}/releases/{version}/{path/components.yaml}
 //
+// (1): {provider-name} must match the value returned by Provider.Name()
+// (2): {version} must exactly obey the syntax and semantics of
+// the "Semantic Versioning" specification (http://semver.org/).
+//
 // Concrete example:
 // /home/user/go/src/sigs.k8s.io/cluster-api-provider-aws/releases/v0.4.7/infrastructure-components.yaml
 // basepath: /home/user/go/src
@@ -41,8 +47,7 @@ import (
 // version: v0.4.7
 // path/component.yaml: infrastructure-components.yaml
 //
-// NOTE: provider-name must match the value returned by Provider.Name()
-// since it is used to parse the above fields.
+
 type localRepository struct {
 	providerConfig        config.Provider
 	configVariablesClient config.VariablesClient
@@ -73,8 +78,18 @@ func (r *localRepository) ComponentsPath() string {
 
 // GetFile returns a file for a given provider version
 func (r *localRepository) GetFile(version, fileName string) ([]byte, error) {
+	var err error
+
+	if version == "latest" {
+		version, err = r.getLatestRelease()
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to get the latest release")
+		}
+	} else if version == "" {
+		version = r.defaultVersion
+	}
 
-	absolutePath := filepath.Join(r.basepath, r.owner, r.providerName, version, r.rootPath, fileName)
+	absolutePath := filepath.Join(r.basepath, r.owner, r.providerName, "releases", version, r.rootPath, fileName)
 
 	if f, err := os.Stat(absolutePath); err == nil {
 		if f.IsDir() {
@@ -86,7 +101,7 @@ func (r *localRepository) GetFile(version, fileName string) ([]byte, error) {
 		}
 		return content, nil
 	}
-	return nil, errors.Errorf("failed to read files from local release %s", version)
+	return nil, errors.Errorf("failed to read files from local release %s, path %s", version, absolutePath)
 
 }
 
@@ -95,7 +110,16 @@ func newLocalRepository(providerConfig config.Provider, configVariablesClient co
 
 	var err error
 
-	if !filepath.IsAbs(providerConfig.URL()) {
+	u, err := url.Parse(providerConfig.URL())
+	if err != nil {
+		return nil, errors.Wrap(err, "invalid url")
+	}
+	absPath := u.Path
+	if u.RawPath != "" {
+		absPath = u.RawPath
+	}
+
+	if !filepath.IsAbs(absPath) {
 		return nil, errors.Errorf("invalid path: path %q must be an absolute path", providerConfig.URL())
 	}
 
@@ -149,6 +173,43 @@ func newLocalRepository(providerConfig config.Provider, configVariablesClient co
 
 // getLatestRelease returns the latest release for the local repository.
 func (r *localRepository) getLatestRelease() (string, error) {
-	// TODO
-	return "0.0.0", nil
+
+	// get all the sub-directories under {releases} directory
+	releasesPath := filepath.Join(r.basepath, r.owner, r.providerName, "releases")
+	files, err := ioutil.ReadDir(releasesPath)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to list release directories")
+	}
+	var releases []string
+	for _, f := range files {
+		if f.IsDir() {
+			releases = append(releases, f.Name())
+		}
+	}
+
+	// search for the latest release according to semantic version
+	// releases with names that are not semantic version number are ignored
+	var latestTag string
+	var latestReleaseVersion *version.Version
+	for _, r := range releases {
+		sv, err := version.ParseSemantic(r)
+		if err != nil {
+			// discard releases with tags that are not a valid semantic versions (the user can point explicitly to such releases)
+			continue
+		}
+		if sv.PreRelease() != "" || sv.BuildMetadata() != "" {
+			// discard pre-releases or build releases (the user can point explicitly to such releases)
+			continue
+		}
+		if latestReleaseVersion == nil || latestReleaseVersion.LessThan(sv) {
+			latestTag = r
+			latestReleaseVersion = sv
+		}
+	}
+
+	if latestTag == "" {
+		return "", errors.New("failed to find releases tagged with a valid semantic version number")
+	}
+
+	return latestTag, nil
 }

cmd/clusterctl/pkg/client/repository/repository_local_unix_test.go

@@ -17,6 +17,9 @@ limitations under the License.
 package repository
 
 import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
 	"testing"
 
 	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
@@ -124,7 +127,7 @@ func Test_localRepository_newLocalRepository(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := newLocalRepository(tt.fields.provider, tt.fields.configVariablesClient)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("newLocalRepository() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 
@@ -152,3 +155,173 @@ func Test_localRepository_newLocalRepository(t *testing.T) {
 		})
 	}
 }
+
+func tempDir(t *testing.T) string {
+	dir, err := ioutil.TempDir("", "cc")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	if err := os.RemoveAll(dir); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return dir
+}
+
+func tempTestLayout(t *testing.T, tmpDir, path, msg string) string {
+
+	dst := filepath.Join(tmpDir, path)
+	// Create all directories in the standard layout
+	if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	err := ioutil.WriteFile(dst, []byte(msg), 0644)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	return dst
+}
+
+func Test_localRepository_newLocalRepository_Latest(t *testing.T) {
+	tmpDir := tempDir(t)
+	defer os.RemoveAll(filepath.Dir(tmpDir))
+
+	// Create several release directories
+	tempTestLayout(t, tmpDir, "owner-foo/provider-2/releases/v1.0.0/infrastructure-components.yaml", "foo: bar")
+	tempTestLayout(t, tmpDir, "owner-foo/provider-2/releases/v1.0.1/infrastructure-components.yaml", "foo: bar")
+	tempTestLayout(t, tmpDir, "owner-foo/provider-2/releases/Foo.Bar/infrastructure-components.yaml", "foo: bar")
+	// Provider URL for the latest release
+	p2URLLatest := "owner-foo/provider-2/releases/latest/infrastructure-components.yaml"
+	p2URLLatestAbs := filepath.Join(tmpDir, p2URLLatest)
+	p2 := config.NewProvider("provider-2", p2URLLatestAbs, clusterctlv1.BootstrapProviderType)
+
+	t.Run("Pass: select latest release from multiple release directories", func(t *testing.T) {
+		got, err := newLocalRepository(p2, test.NewFakeVariableClient())
+		if err != nil {
+			t.Errorf("newLocalRepository() got error %v", err)
+			return
+		}
+
+		if got.basepath != tmpDir {
+			t.Errorf("basepath() got = %v, want = %v ", got.basepath, tmpDir)
+		}
+		if got.owner != "owner-foo" {
+			t.Errorf("owner() got = %v, want = owner-foo ", got.owner)
+		}
+		if got.providerName != "provider-2" {
+			t.Errorf("providerName() got = %v, want = provider-2 ", got.providerName)
+		}
+		if got.DefaultVersion() != "v1.0.1" {
+			t.Errorf("DefaultVersion() got = %v, want = v1.0.1 ", got.DefaultVersion())
+		}
+		if got.RootPath() != "" {
+			t.Errorf("RootPath() got = %v, want = \"\" ", got.RootPath())
+		}
+		if got.ComponentsPath() != "infrastructure-components.yaml" {
+			t.Errorf("ComponentsPath() got = %v, want = infrastructure-components.yaml ", got.ComponentsPath())
+		}
+	})
+}
+
+func Test_localRepository_GetFile(t *testing.T) {
+	tmpDir := tempDir(t)
+	defer os.RemoveAll(filepath.Dir(tmpDir))
+
+	// Provider 1: URL is for the only release available
+	dst1 := tempTestLayout(t, tmpDir, "owner-foo/provider-1/releases/v1.0.0/infrastructure-components.yaml", "foo: bar")
+	p1 := config.NewProvider("provider-1", dst1, clusterctlv1.BootstrapProviderType)
+
+	// Provider 2: URL is for the latest release
+	tempTestLayout(t, tmpDir, "owner-foo/provider-2/releases/v1.0.0/infrastructure-components.yaml", "version: v1.0.0")
+	tempTestLayout(t, tmpDir, "owner-foo/provider-2/releases/v1.0.1/infrastructure-components.yaml", "version: v1.0.1")
+	tempTestLayout(t, tmpDir, "owner-foo/provider-2/releases/Foo.Bar/infrastructure-components.yaml", "version: Foo.Bar")
+	p2URLLatest := "owner-foo/provider-2/releases/latest/infrastructure-components.yaml"
+	p2URLLatestAbs := filepath.Join(tmpDir, p2URLLatest)
+	p2 := config.NewProvider("provider-2", p2URLLatestAbs, clusterctlv1.BootstrapProviderType)
+
+	type fields struct {
+		provider              config.Provider
+		configVariablesClient config.VariablesClient
+	}
+	type args struct {
+		version  string
+		fileName string
+	}
+	type want struct {
+		contents string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    want
+		wantErr bool
+	}{
+		{
+			name: "Get file from release directory",
+			fields: fields{
+				provider:              p1,
+				configVariablesClient: test.NewFakeVariableClient(),
+			},
+			args: args{
+				version:  "v1.0.0",
+				fileName: "infrastructure-components.yaml",
+			},
+			want: want{
+				contents: "foo: bar",
+			},
+			wantErr: false,
+		},
+		{
+			name: "Get file from latest release directory",
+			fields: fields{
+				provider:              p2,
+				configVariablesClient: test.NewFakeVariableClient(),
+			},
+			args: args{
+				version:  "latest",
+				fileName: "infrastructure-components.yaml",
+			},
+			want: want{
+				contents: "version: v1.0.1", // We use the file contents to determine data was read from latest release
+			},
+			wantErr: false,
+		},
+		{
+			name: "Get file from default version release directory",
+			fields: fields{
+				provider:              p2,
+				configVariablesClient: test.NewFakeVariableClient(),
+			},
+			args: args{
+				version:  "",
+				fileName: "infrastructure-components.yaml",
+			},
+			want: want{
+				contents: "version: v1.0.1", // We use the file contents to determine data was read from latest release
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r, err := newLocalRepository(tt.fields.provider, tt.fields.configVariablesClient)
+			if err != nil {
+				t.Errorf("newLocalRepository() threw unexpected error: %v", err)
+				return
+			}
+			got, err := r.GetFile(tt.args.version, tt.args.fileName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetFile() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.wantErr {
+				return
+			}
+			if string(got) != tt.want.contents {
+				t.Errorf("GetFile() returned %s expected %s", got, tt.want.contents)
+			}
+		})
+	}
+}