Added GetVersions() support.

Simplified the directory layout.
Incorporated feedback.

Author: Arvinderpal

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

@@ -33,26 +33,23 @@ import (
 // path to the components yaml on the local filesystem.
 // In order to support different versions, the directories containing provider
 // specific data must adhere to the following layout:
-// {basepath}/{owner}/{provider-name}/releases/{version}/{path/components.yaml}
+// {basepath}/{provider-name}/{version}/{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
-// owner : sigs.k8s.io
-// provider-name: cluster-api-provider-aws
+// /home/user/go/src/sigs.k8s.io/aws/v0.4.7/infrastructure-components.yaml
+// basepath: /home/user/go/src/sigs.k8s.io
+// provider-name: aws
 // version: v0.4.7
-// path/component.yaml: infrastructure-components.yaml
-//
+// component.yaml: infrastructure-components.yaml
 
 type localRepository struct {
 	providerConfig        config.Provider
 	configVariablesClient config.VariablesClient
 	basepath              string
-	owner                 string
 	providerName          string
 	defaultVersion        string
 	rootPath              string
@@ -89,7 +86,7 @@ func (r *localRepository) GetFile(version, fileName string) ([]byte, error) {
 		version = r.defaultVersion
 	}
 
-	absolutePath := filepath.Join(r.basepath, r.owner, r.providerName, "releases", version, r.rootPath, fileName)
+	absolutePath := filepath.Join(r.basepath, r.providerName, version, r.rootPath, fileName)
 
 	if f, err := os.Stat(absolutePath); err == nil {
 		if f.IsDir() {
@@ -105,59 +102,64 @@ func (r *localRepository) GetFile(version, fileName string) ([]byte, error) {
 
 }
 
+// GetVersion returns the list of versions that are available for a local repository
+func (r *localRepository) GetVersions() ([]string, error) {
+	versions, err := r.getVersions()
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get local repository versions")
+	}
+	return versions, nil
+}
+
 // newLocalRepository returns a localRepository implementation
 func newLocalRepository(providerConfig config.Provider, configVariablesClient config.VariablesClient) (*localRepository, error) {
 
 	var err error
 
-	u, err := url.Parse(providerConfig.URL())
+	urlSplit, err := url.Parse(providerConfig.URL())
 	if err != nil {
 		return nil, errors.Wrap(err, "invalid url")
 	}
-	absPath := u.Path
-	if u.RawPath != "" {
-		absPath = u.RawPath
+	absPath := urlSplit.Path
+	if urlSplit.RawPath != "" {
+		absPath = urlSplit.RawPath
 	}
 
 	if !filepath.IsAbs(absPath) {
 		return nil, errors.Errorf("invalid path: path %q must be an absolute path", providerConfig.URL())
 	}
 
 	parts := strings.Split(providerConfig.URL(), "/")
-	// find the first occurance of provider name and use it as a seperator between base and layout
-	providerNameIndex := 0
-	for i, p := range parts {
-		if p == providerConfig.Name() {
-			providerNameIndex = i
+	// {basepath}/{provider-name}/{version}/{components.yaml}
+	if len(parts) < 3 {
+		return nil, errors.Errorf("invalid path: path should be in the form {basepath}/{provider-name}/{version}/{components.yaml}")
+	}
+	// We work our way backwards with {components.yaml} being the last part of the path
+	componentsPath := parts[len(parts)-1]
+	defaultVersion := parts[len(parts)-2]
+	if defaultVersion != "latest" {
+		_, err = version.ParseSemantic(defaultVersion)
+		if err != nil {
+			return nil, errors.Errorf("invalid version: %q. Version must obey the syntax and semantics of the \"Semantic Versioning\" specification (http://semver.org/) and path format {basepath}/{provider-name}/{version}/{components.yaml}", defaultVersion)
 		}
 	}
-	if providerNameIndex < 1 {
-		return nil, errors.Errorf("invalid path: path %q must contain provider name %q", providerConfig.URL(), providerConfig.Name())
+	providerName := parts[len(parts)-3]
+	if providerName != providerConfig.Name() {
+		return nil, errors.Errorf("invalid path: path %q must contain provider name %q in the format {basepath}/{provider-name}/{version}/{components.yaml}", providerConfig.URL(), providerConfig.Name())
+	}
+	var basePath string
+	if len(parts) > 3 {
+		basePath = filepath.Join(parts[:len(parts)-3]...)
 	}
-
-	basePath := filepath.Join(parts[:providerNameIndex-1]...)
 	basePath = filepath.Clean("/" + basePath) // ensure basePath starts with "/"
-	layoutPath := filepath.Join(parts[providerNameIndex-1:]...)
-	layoutParts := strings.Split(layoutPath, "/")
-	// Check if the layoutPath is in the expected format.
-	if len(layoutParts) < 5 {
-		return nil, errors.Errorf("invalid path: path should be in the form {basepath}/{owner}/{provider-name}/releases/{version}/{path/components.yaml}")
-	}
-	owner := layoutParts[0]
-	providerName := layoutParts[1]
-	defaultVersion := layoutParts[3]
-	path := filepath.Join(layoutParts[4:]...)
-	// rootpath is the relative path starting after {version} directory and excludes component fiename
-	rootPath, componentsPath := filepath.Split(path)
 
 	repo := &localRepository{
 		providerConfig:        providerConfig,
 		configVariablesClient: configVariablesClient,
 		basepath:              basePath,
-		owner:                 owner,
 		providerName:          providerName,
 		defaultVersion:        defaultVersion,
-		rootPath:              rootPath,
+		rootPath:              "", // Not applicable with localRepository
 		componentsPath:        componentsPath,
 	}
 
@@ -174,36 +176,32 @@ func newLocalRepository(providerConfig config.Provider, configVariablesClient co
 // getLatestRelease returns the latest release for the local repository.
 func (r *localRepository) getLatestRelease() (string, error) {
 
-	// get all the sub-directories under {releases} directory
-	releasesPath := filepath.Join(r.basepath, r.owner, r.providerName, "releases")
+	// get all the sub-directories under {basepath}/{provider-name}/
+	releasesPath := filepath.Join(r.basepath, r.providerName)
 	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
+	for _, f := range files {
+		if f.IsDir() {
+			r := f.Name()
+			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
+			}
 		}
 	}
 
@@ -213,3 +211,30 @@ func (r *localRepository) getLatestRelease() (string, error) {
 
 	return latestTag, nil
 }
+
+// getVersions returns all the release versions for a local repository
+func (r *localRepository) getVersions() ([]string, error) {
+	// get all the sub-directories under {basepath}/{provider-name}/
+	releasesPath := filepath.Join(r.basepath, r.providerName)
+	files, err := ioutil.ReadDir(releasesPath)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to list release directories")
+	}
+	var versions []string
+	for _, f := range files {
+		if f.IsDir() {
+			r := f.Name()
+			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
+			}
+			versions = append(versions, r)
+		}
+	}
+	return versions, nil
+}