chore: sync with upstream FairwindsOps/nova

.gitignore

@@ -15,3 +15,4 @@ node_modules
 /dist
 
 /nova.yaml
+docs/README.md

cmd/root.go

@@ -49,6 +49,7 @@ func init() {
 		findCmd,
 		genConfigCmd,
 	)
+
 	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "Config file to use. If empty, flags will be used instead")
 	rootCmd.PersistentFlags().String("output-file", "", "Path on local filesystem to write file output to")
 	err := viper.BindPFlag("output-file", rootCmd.PersistentFlags().Lookup("output-file"))
@@ -92,6 +93,12 @@ func init() {
 		klog.Exitf("Failed to bind context flag: %v", err)
 	}
 
+	rootCmd.PersistentFlags().String("kubeconfig", "", "A path to a kubeconfig file.")
+	err = viper.BindPFlag("kubeconfig", rootCmd.PersistentFlags().Lookup("kubeconfig"))
+	if err != nil {
+		klog.Exitf("Failed to bind kubeconfig flag: %v", err)
+	}
+
 	rootCmd.PersistentFlags().Bool("wide", false, "Output chart name and namespace")
 	err = viper.BindPFlag("wide", rootCmd.PersistentFlags().Lookup("wide"))
 	if err != nil {
@@ -247,14 +254,15 @@ var findCmd = &cobra.Command{
 		klog.V(5).Infof("All Keys: %v", viper.AllKeys())
 
 		kubeContext := viper.GetString("context")
+		kubeConfigPath := viper.GetString("kubeconfig")
 
 		format := viper.GetString("format")
 		if !(format == output.TableFormat || format == output.JSONFormat) {
 			klog.Exitf("--format flag value is not valid. Run `nova find --help` to see flag options")
 		}
 
 		if viper.GetBool("helm") && viper.GetBool("containers") {
-			output, err := handleHelmAndContainers(kubeContext)
+			output, err := handleHelmAndContainers(kubeContext, kubeConfigPath)
 			if err != nil {
 				klog.Exit(err)
 			}
@@ -271,15 +279,15 @@ var findCmd = &cobra.Command{
 		}
 
 		if viper.GetBool("containers") {
-			output, err := handleContainers(kubeContext)
+			output, err := handleContainers(kubeContext, kubeConfigPath)
 			if err != nil {
 				klog.Exit(err)
 			}
 			output.Print(format)
 			return
 		}
 
-		output, err := handleHelm(kubeContext)
+		output, err := handleHelm(kubeContext, kubeConfigPath)
 		if err != nil {
 			klog.Exit(err)
 		}
@@ -316,7 +324,7 @@ func Execute(VERSION, COMMIT string) {
 	}
 }
 
-func handleContainers(kubeContext string) (*output.ContainersOutput, error) {
+func handleContainers(kubeContext, kubeConfigPath string) (*output.ContainersOutput, error) {
 	// Set up a context we can use to cancel all operations to external container registries if we need to
 	timeout := time.Duration(viper.GetUint16("timeout")) * time.Second
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -334,7 +342,7 @@ func handleContainers(kubeContext string) (*output.ContainersOutput, error) {
 		case <-ctx.Done():
 		}
 	}()
-	iClient := containers.NewClient(kubeContext)
+	iClient := containers.NewClient(kubeContext, kubeConfigPath)
 	namespace := viper.GetString("namespace")
 	if viper.IsSet("namespace") {
 		klog.V(3).Infof("Scanning namespace %v", namespace)
@@ -351,8 +359,8 @@ func handleContainers(kubeContext string) (*output.ContainersOutput, error) {
 	return output.NewContainersOutput(containers.Images, containers.ErrImages, showNonSemver, showErrored, includeAll), nil
 }
 
-func handleHelm(kubeContext string) (*output.Output, error) {
-	h := nova_helm.NewHelm(kubeContext)
+func handleHelm(kubeContext, kubeConfigPath string) (*output.Output, error) {
+	h := nova_helm.NewHelm(kubeContext, kubeConfigPath)
 	if viper.IsSet("desired-versions") {
 		klog.V(3).Infof("desired-versions is set - attempting to load them")
 		klog.V(8).Infof("raw desired-versions: %v", viper.Get("desired-versions"))
@@ -414,12 +422,12 @@ func handleHelm(kubeContext string) (*output.Output, error) {
 	return &out, nil
 }
 
-func handleHelmAndContainers(kubeContext string) (*output.HelmAndContainersOutput, error) {
-	helmOutput, err := handleHelm(kubeContext)
+func handleHelmAndContainers(kubeContext, kubeConfigPath string) (*output.HelmAndContainersOutput, error) {
+	helmOutput, err := handleHelm(kubeContext, kubeConfigPath)
 	if err != nil {
 		return nil, err
 	}
-	containersOutput, err := handleContainers(kubeContext)
+	containersOutput, err := handleContainers(kubeContext, kubeConfigPath)
 	if err != nil {
 		return nil, err
 	}

pkg/containers/images.go

@@ -93,9 +93,9 @@ type Tag struct {
 }
 
 // NewClient is a constructor to create a new Client
-func NewClient(kubeContext string) *Client {
+func NewClient(kubeContext, kubeConfigPath string) *Client {
 	return &Client{
-		Kube: kube.GetConfigInstance(kubeContext),
+		Kube: kube.GetConfigInstance(kubeContext, kubeConfigPath),
 	}
 }
 

pkg/containers/images_test.go

@@ -98,15 +98,15 @@ func TestGetContainerImages(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	var obj map[string]interface{}
+	var obj map[string]any
 	err = json.Unmarshal(b, &obj)
 	if err != nil {
 		t.Error(err)
 	}
 	fakeTopControllerGetter := func(ns string) ([]controller.Workload, error) {
 		return []controller.Workload{
 			{
-				TopController: unstructured.Unstructured{Object: map[string]interface{}{"kind": "Deployment", "metadata": map[string]interface{}{"name": "name", "namespace": "my-namespace"}}},
+				TopController: unstructured.Unstructured{Object: map[string]any{"kind": "Deployment", "metadata": map[string]any{"name": "name", "namespace": "my-namespace"}}},
 				Pods:          []unstructured.Unstructured{{Object: obj}},
 			},
 		}, nil

pkg/helm/artifacthub.go

@@ -110,6 +110,7 @@ type ArtifactHubHelmPackage struct {
 	AvailableVersions []AvailableVersion    `json:"available_versions"`
 	Maintainers       []Maintainer          `json:"maintainers"`
 	Links             []Link                `json:"links"`
+	Stars             int                   `json:"stars"`
 }
 
 // AvailableVersion is a sub struct of ArtifactHubHelmPackage and provides a version that is available for a given helm chart.

pkg/helm/artifacthub_cached.go

@@ -61,6 +61,7 @@ type ArtifactHubCachedPackage struct {
 	Links         []Link                         `json:"links"`
 	Maintainers   []Maintainer                   `json:"maintainers"`
 	Deprecated    bool                           `json:"deprecated"`
+	Stars         int                            `json:"stars"`
 }
 
 // ArtifactHubCachedRepository is a sub-struct of the Package struct, and represents the repository containing the package.
@@ -126,6 +127,7 @@ func (ac *ArtifactHubCachedPackageClient) List() ([]ArtifactHubHelmPackage, erro
 			HomeURL:     cachedPackage.HomeURL,
 			Links:       cachedPackage.Links,
 			Official:    cachedPackage.Official,
+			Stars:       cachedPackage.Stars,
 			Repository: ArtifactHubRepository{
 				Name:              cachedPackage.Repository.Name,
 				URL:               cachedPackage.Repository.URL,

pkg/helm/cluster.go

@@ -16,6 +16,7 @@ package helm
 
 import (
 	"fmt"
+	"slices"
 
 	"github.com/fairwindsops/nova/pkg/kube"
 	"github.com/fairwindsops/nova/pkg/output"
@@ -39,9 +40,9 @@ type DesiredVersion struct {
 }
 
 // NewHelm returns a basic helm struct with the version of helm requested
-func NewHelm(kubeContext string) *Helm {
+func NewHelm(kubeContext, kubeConfigPath string) *Helm {
 	return &Helm{
-		Kube: kube.GetConfigInstance(kubeContext),
+		Kube: kube.GetConfigInstance(kubeContext, kubeConfigPath),
 	}
 }
 
@@ -96,11 +97,8 @@ func filterIgnoredReleases(deployed []*release.Release, releaseIgnoreList []stri
 	for _, release := range deployed {
 		isIgnoredRelease := false
 		isIgnoredChart := false
-		for _, ignoreListedRelease := range releaseIgnoreList {
-			if release.Name == ignoreListedRelease {
-				isIgnoredRelease = true
-				break
-			}
+		if slices.Contains(releaseIgnoreList, release.Name) {
+			isIgnoredRelease = true
 		}
 		for _, ignoreListedChart := range chartIgnoreList {
 			// Check for nil to avoid a potential nil pointer exception

pkg/helm/findscore.go

@@ -15,6 +15,7 @@
 package helm
 
 import (
+	"slices"
 	"strings"
 
 	"github.com/fairwindsops/nova/pkg/output"
@@ -23,22 +24,56 @@ import (
 	"k8s.io/klog/v2"
 )
 
+const useStarCountThreshold = 10
+
+type packageKey struct {
+	Name       string
+	Repository string
+}
+
 // FindBestArtifactHubMatch takes the helm releases found in the cluster and attempts to match those to a package in artifacthub
 func FindBestArtifactHubMatch(clusterRelease *release.Release, ahubPackages []ArtifactHubHelmPackage) *output.ReleaseOutput {
-	var highScore int
-	var highScorePackage ArtifactHubHelmPackage
+	packagesByName := map[packageKey]ArtifactHubHelmPackage{}
+	packageScores := map[packageKey]float32{}
+	packageStars := map[packageKey]int{}
+	var useStars bool
 	for _, p := range ahubPackages {
-		score := 0
 		if p.Name != clusterRelease.Chart.Metadata.Name {
 			continue
 		}
-		score = scoreChartSimilarity(clusterRelease, p)
+
+		key := packageKey{Name: p.Name, Repository: p.Repository.Name}
+		packageScores[key] = scoreChartSimilarity(clusterRelease, p)
+		packagesByName[key] = p
+		packageStars[key] = p.Stars
+
+		if p.Stars >= useStarCountThreshold {
+			useStars = true // If any package has more than 10 stars, we add a point to the highest star package
+		}
+	}
+
+	var highestStarPackage packageKey
+	var highStars int
+	for p, stars := range packageStars {
+		if stars > highStars {
+			highStars = stars
+			highestStarPackage = p
+		}
+	}
+
+	var highScore float32
+	var highScorePackage ArtifactHubHelmPackage
+	for k, score := range packageScores {
+		if useStars && highStars > 0 && k == highestStarPackage {
+			klog.V(10).Infof("adding a point to the highest star package: %s:%s", k.Repository, k.Name)
+			score++ // Add a point to the highest star package
+		}
 		if score > highScore {
 			highScore = score
-			highScorePackage = p
+			highScorePackage = packagesByName[k]
 		}
 	}
-	klog.V(10).Infof("highScore for '%s': %d, highScorePackage Repo: %s", clusterRelease.Chart.Metadata.Name, highScore, highScorePackage.Repository.Name)
+	klog.V(10).Infof("highScore for '%s': %f, highScorePackage Repo: %s", clusterRelease.Chart.Metadata.Name, highScore, highScorePackage.Repository.Name)
 	return prepareOutput(clusterRelease, highScorePackage)
 }
 
@@ -98,14 +133,12 @@ func prepareOutput(release *release.Release, pkg ArtifactHubHelmPackage) *output
 	}
 }
 
-func scoreChartSimilarity(release *release.Release, pkg ArtifactHubHelmPackage) int {
-	ret := 0
-	var preferredRepositories = []string{
-		"bitnami",
-		"fairwinds-stable",
-		"ingress-nginx",
-		"cert-manager",
-	}
+var preferredRepositories = []string{"bitnami", "fairwinds-stable", "fairwinds-incubator", "ingress-nginx", "cert-manager", "projectcalico",
+	"grafana", "prometheus-community", "elastic", "hashicorp", "argo", "metrics-server", "gitlab", "jenkins", "harbor", "minio", "cluster-autoscaler",
+	"aws-ebs-csi-driver", "coredns", "datadog", "deliveryhero", "falcosecurity", "kedacore", "kured", "oauth2-proxy", "rimusz"}
+
+func scoreChartSimilarity(release *release.Release, pkg ArtifactHubHelmPackage) float32 {
+	var ret float32
 	if release.Chart.Metadata.Home == pkg.HomeURL {
 		klog.V(10).Infof("+1 score for %s Home URL (ahub package repo %s)", release.Chart.Metadata.Name, pkg.Repository.Name)
 		ret++
@@ -153,10 +186,10 @@ func scoreChartSimilarity(release *release.Release, pkg ArtifactHubHelmPackage)
 		ret++
 	}
 	if containsString(preferredRepositories, pkg.Repository.Name) {
-		klog.V(10).Infof("+1 score for %s, preffered repo (ahub package repo %s)", release.Chart.Metadata.Name, pkg.Repository.Name)
-		ret++
+		klog.V(10).Infof("+1.5 score for %s, preferred repo (ahub package repo %s)", release.Chart.Metadata.Name, pkg.Repository.Name)
+		ret += 1.5
 	}
-	klog.V(10).Infof("calculated score repo: %s, release: %s, score: %d\n\n", pkg.Repository.Name, release.Name, ret)
+	klog.V(10).Infof("calculated score repo: %s, release: %s, stars: %d, score: %f\n\n", pkg.Repository.Name, release.Name, pkg.Stars, ret)
 	return ret
 }
 
@@ -170,12 +203,7 @@ func clusterVersionExistsInPackage(clusterVersion string, pkg ArtifactHubHelmPac
 }
 
 func containsString(arr []string, val string) bool {
-	for _, item := range arr {
-		if item == val {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(arr, val)
 }
 
 // IsValidRelease returns a bool indicating whether a version string is valid or not.

pkg/helm/findscore_test.go

@@ -103,13 +103,13 @@ func Test_scoreChartSimilarity(t *testing.T) {
 		name    string
 		release *release.Release
 		pkg     ArtifactHubHelmPackage
-		want    int
+		want    float32
 	}{
 		{
 			name:    "highest score",
 			release: helmRelease,
 			pkg:     ahubPackage,
-			want:    7,
+			want:    7.5,
 		},
 		{
 			name:    "empty pkg struct",