Remove flux check from check cmd (#1551)

* Remove flux check and binary from check cmd

* lint

* cleanup

Co-authored-by: Justin Thompson <jpthomp12@gmail.com>

cmd/gitops/check/cmd.go

@@ -1,19 +1,11 @@
 package check
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/weaveworks/weave-gitops/pkg/services/check"
-	"github.com/weaveworks/weave-gitops/pkg/version"
-
-	"github.com/weaveworks/weave-gitops/pkg/osys"
-	"github.com/weaveworks/weave-gitops/pkg/runner"
-
-	"github.com/weaveworks/weave-gitops/pkg/flux"
 
 	"github.com/spf13/cobra"
-	"github.com/weaveworks/weave-gitops/pkg/kube"
 )
 
 var (
@@ -35,25 +27,7 @@ func init() {
 }
 
 func runCmd(_ *cobra.Command, _ []string) error {
-	ctx := context.Background()
-
-	fluxClient := flux.New(osys.New(), &runner.CLIRunner{})
-
-	rest, clusterName, err := kube.RestConfig()
-	if err != nil {
-		return fmt.Errorf("failed getting rest config: %w", err)
-	}
-
-	_, k8sClient, err := kube.NewKubeHTTPClientWithConfig(rest, clusterName)
-	if err != nil {
-		return fmt.Errorf("failed creating k8s client: %w", err)
-	}
-
-	kubeClient := &kube.KubeHTTP{
-		Client: k8sClient,
-	}
-
-	output, err := check.Pre(ctx, kubeClient, fluxClient, version.FluxVersion)
+	output, err := check.Pre()
 	if err != nil {
 		return err
 	}

pkg/flux/flux.go

@@ -17,7 +17,6 @@ type Flux interface {
 	SetupBin()
 	CreateSecretGit(name string, repoUrl gitproviders.RepoURL, namespace string) ([]byte, error)
 	GetAllResourcesStatus(name string, namespace string) ([]byte, error)
-	PreCheck() (string, error)
 }
 
 const (
@@ -96,17 +95,3 @@ func (f *FluxClient) fluxPath() (string, error) {
 
 	return fmt.Sprintf("%v/flux-%v", path, version.FluxVersion), nil
 }
-
-func (f *FluxClient) PreCheck() (string, error) {
-	args := []string{
-		"check",
-		"--pre",
-	}
-
-	output, err := f.runFluxCmd(args...)
-	if err != nil {
-		return "", fmt.Errorf("failed running flux pre check %w", err)
-	}
-
-	return string(output), nil
-}

pkg/services/check/check.go

@@ -1,118 +1,70 @@
 package check
 
 import (
-	"context"
-	"errors"
 	"fmt"
+	"os/exec"
 	"strings"
 
 	"github.com/Masterminds/semver/v3"
-	"github.com/weaveworks/weave-gitops/pkg/flux"
-	"github.com/weaveworks/weave-gitops/pkg/kube"
 )
 
-var ErrKubernetesNotFound = errors.New("no kubernetes version found")
-
 const (
-	FluxCompatibleMessage    = "Current flux version is compatible"
-	FluxNotCompatibleMessage = "Current flux version is not compatible"
+	kubernetesConstraints = ">=1.20.6-0"
 )
 
 // Pre runs pre-install checks
-func Pre(ctx context.Context, kubeClient kube.Kube, fluxClient flux.Flux, expectedFluxVersion string) (string, error) {
-	output := ""
-
-	k8sOutput, err := runKubernetesCheck(fluxClient)
+func Pre() (string, error) {
+	k8sOutput, err := runKubernetesCheck()
 	if err != nil {
 		return "", err
 	}
 
-	output += k8sOutput + "\n"
+	return k8sOutput, nil
+}
 
-	currentFluxVersion, err := getCurrentFluxVersion(ctx, kubeClient)
+func runKubernetesCheck() (string, error) {
+	versionOutput, err := exec.Command("kubectl", "version", "--short").CombinedOutput()
 	if err != nil {
-		if errors.Is(err, kube.ErrNamespaceNotFound) {
-			output += "✔ Flux is not installed"
-			return output, nil
-		}
-
-		return "", fmt.Errorf("failed getting installed flux version: %w", err)
+		return "", fmt.Errorf("unable to get kubernetes version: %w", err)
 	}
 
-	fluxOutput, err := validateFluxVersion(currentFluxVersion, expectedFluxVersion)
+	v, err := parseVersion(string(versionOutput))
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("kubernetes version can't be determined: %w", err)
 	}
 
-	output += fluxOutput
-
-	return output, nil
+	return checkKubernetesVersion(v)
 }
 
-func runKubernetesCheck(fluxClient flux.Flux) (string, error) {
-	output, err := fluxClient.PreCheck()
-	if err != nil {
-		return "", fmt.Errorf("failed running flux pre check %w", err)
-	}
+func checkKubernetesVersion(version *semver.Version) (string, error) {
+	var valid bool
 
-	lines := strings.Split(output, "\n")
-	for _, line := range lines {
-		if strings.Contains(line, "Kubernetes") {
-			return line, nil
-		}
-	}
-
-	return "", ErrKubernetesNotFound
-}
+	var vrange string
 
-func getCurrentFluxVersion(ctx context.Context, kubeClient kube.Kube) (string, error) {
-	namespace, err := kubeClient.FetchNamespaceWithLabel(ctx, flux.PartOfLabelKey, flux.PartOfLabelValue)
-	if err != nil {
-		return "", err
+	c, _ := semver.NewConstraint(kubernetesConstraints)
+	if c.Check(version) {
+		valid = true
+		vrange = kubernetesConstraints
 	}
 
-	labels := namespace.GetLabels()
-
-	return labels[flux.VersionLabelKey], nil
-}
-
-func validateFluxVersion(actualFluxVersion string, expectedFluxVersion string) (string, error) {
-	actualParsedFluxVersion, err := parseVersion(actualFluxVersion)
-	if err != nil {
-		return "", err
-	}
-
-	expectedParsedFluxVersion, err := parseVersion(expectedFluxVersion)
-	if err != nil {
-		return "", err
+	if !valid {
+		return "", fmt.Errorf("✗ kubernetes version %s does not match %s", version.Original(), kubernetesConstraints)
 	}
 
-	fluxOutput := ""
-
-	expectedMajor := expectedParsedFluxVersion.Major()
-	expectedMinor := expectedParsedFluxVersion.Minor()
-	constraintFormat := fmt.Sprintf("~%d.%d.x", expectedMajor, expectedMinor)
+	return fmt.Sprintf("✔ Kubernetes %s %s", version.String(), vrange), nil
+}
 
-	constraint, err := semver.NewConstraint(constraintFormat)
-	if err != nil {
-		return "", fmt.Errorf("failed creating semver constraint: %w", err)
-	}
+func parseVersion(text string) (*semver.Version, error) {
+	version := ""
+	lines := strings.Split(text, "\n")
 
-	check := constraint.Check(actualParsedFluxVersion)
-	if check {
-		fluxOutput += fmt.Sprintf("✔ Flux %s ~=%s\n", actualParsedFluxVersion, expectedParsedFluxVersion)
-		fluxOutput += FluxCompatibleMessage
-	} else {
-		fluxOutput += fmt.Sprintf("✗ Flux %s !=%s\n", actualParsedFluxVersion, constraintFormat)
-		fluxOutput += FluxNotCompatibleMessage
+	for _, line := range lines {
+		if strings.Contains(line, "Server") {
+			version = strings.Replace(line, "Server Version: v", "", 1)
+		}
 	}
 
-	return fluxOutput, nil
-}
-
-func parseVersion(version string) (*semver.Version, error) {
-	versionLessV := strings.TrimPrefix(version, "v")
-	if _, err := semver.StrictNewVersion(versionLessV); err != nil {
+	if _, err := semver.StrictNewVersion(version); err != nil {
 		return nil, err
 	}