Merge pull request #1828 from FabianKramm/master

refactor: allow beta / alpha in require

Author: FabianKramm

go.mod

@@ -17,7 +17,6 @@ require (
 	github.com/golang/protobuf v1.5.2
 	github.com/google/uuid v1.1.2
 	github.com/gorilla/websocket v1.4.2
-	github.com/hashicorp/go-version v1.3.0
 	github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf // indirect
 	github.com/joho/godotenv v1.3.0
 	github.com/json-iterator/go v1.1.12

go.sum

@@ -644,8 +644,6 @@ github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdv
 github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
-github.com/hashicorp/go-version v1.3.0 h1:McDWVJIU/y+u1BRV06dPaLfLCaT7fUTJLp5r04x7iNw=
-github.com/hashicorp/go-version v1.3.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=

pkg/devspace/config/loader/loader.go

@@ -2,6 +2,7 @@ package loader
 
 import (
 	"fmt"
+	"github.com/loft-sh/devspace/pkg/util/constraint"
 	"io/ioutil"
 	"os"
 	"os/exec"
@@ -26,8 +27,6 @@ import (
 	"github.com/loft-sh/devspace/pkg/util/kubeconfig"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/loft-sh/devspace/pkg/util/vars"
-
-	version "github.com/hashicorp/go-version"
 )
 
 // DefaultCommandVersionRegEx is the default regex to use if no regex is specified for determining the commands version
@@ -166,17 +165,17 @@ func (l *configLoader) ensureRequires(config *latest.Config, log log.Logger) err
 	}
 
 	if config.Require.DevSpace != "" {
-		constraint, err := version.NewConstraint(config.Require.DevSpace)
+		parsedConstraint, err := constraint.NewConstraint(config.Require.DevSpace)
 		if err != nil {
 			return errors.Wrap(err, "parsing require.devspace")
 		}
 
-		v, err := version.NewSemver(upgrade.GetVersion())
+		v, err := constraint.NewSemver(upgrade.GetVersion())
 		if err != nil {
 			return errors.Wrap(err, "parsing devspace version")
 		}
 
-		if !constraint.Check(v) {
+		if !parsedConstraint.Check(v) {
 			return fmt.Errorf("DevSpace version mismatch: %s (currently installed) does not match %s (required by config). Please make sure you have installed DevSpace with version %s", upgrade.GetVersion(), config.Require.DevSpace, config.Require.DevSpace)
 		}
 	}
@@ -191,17 +190,17 @@ func (l *configLoader) ensureRequires(config *latest.Config, log log.Logger) err
 				return fmt.Errorf("cannot find plugin '%s', however it is required by the config. Please make sure you have installed the plugin '%s' with version %s", p.Name, p.Name, p.Version)
 			}
 
-			constraint, err := version.NewConstraint(p.Version)
+			parsedConstraint, err := constraint.NewConstraint(p.Version)
 			if err != nil {
 				return errors.Wrapf(err, "parsing require.plugins[%d].version", index)
 			}
 
-			v, err := version.NewSemver(metadata.Version)
+			v, err := constraint.NewSemver(metadata.Version)
 			if err != nil {
 				return errors.Wrapf(err, "parsing plugin %s version", p.Name)
 			}
 
-			if !constraint.Check(v) {
+			if !parsedConstraint.Check(v) {
 				return fmt.Errorf("plugin '%s' version mismatch: %s (currently installed) does not match %s (required by config). Please make sure you have installed the plugin '%s' with version %s", p.Name, metadata.Version, p.Version, p.Name, p.Version)
 			}
 		}
@@ -223,7 +222,7 @@ func (l *configLoader) ensureRequires(config *latest.Config, log log.Logger) err
 			return errors.Wrapf(err, "parsing require.commands[%d].versionRegEx", index)
 		}
 
-		constraint, err := version.NewConstraint(c.Version)
+		parsedConstraint, err := constraint.NewConstraint(c.Version)
 		if err != nil {
 			return errors.Wrapf(err, "parsing require.commands[%d].version", index)
 		}
@@ -238,12 +237,12 @@ func (l *configLoader) ensureRequires(config *latest.Config, log log.Logger) err
 			return fmt.Errorf("command %s %s output does not match the provided regex '%s', however the command is required by the config. Please make sure you have correctly installed '%s' with version %s", c.Name, strings.Join(versionArgs, " "), regExString, c.Name, c.Version)
 		}
 
-		v, err := version.NewSemver(matches[1])
+		v, err := constraint.NewSemver(matches[1])
 		if err != nil {
 			return fmt.Errorf("command %s %s output does not return a semver version, however the command is required by the config. Please make sure you have correctly installed '%s' with version %s", c.Name, strings.Join(versionArgs, " "), c.Name, c.Version)
 		}
 
-		if !constraint.Check(v) {
+		if !parsedConstraint.Check(v) {
 			return fmt.Errorf("command '%s' version mismatch: %s (currently installed) does not match %s (required by config). Please make sure you have correctly installed '%s' with version %s", c.Name, matches[1], c.Version, c.Name, c.Version)
 		}
 	}

pkg/devspace/deploy/deployer/kubectl/builder.go

@@ -2,12 +2,12 @@ package kubectl
 
 import (
 	"fmt"
+	"github.com/loft-sh/devspace/pkg/util/constraint"
 	"os/exec"
 	"regexp"
 	"strings"
 
 	"github.com/ghodss/yaml"
-	version "github.com/hashicorp/go-version"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 	"github.com/loft-sh/devspace/pkg/util/command"
 	"github.com/loft-sh/devspace/pkg/util/log"
@@ -83,13 +83,13 @@ var useOldDryRun = func(path string) (bool, error) {
 		return false, err
 	}
 
-	v1, err := version.NewVersion(strings.TrimPrefix(strings.TrimSpace(string(out)), "Client Version: v"))
+	v1, err := constraint.NewVersion(strings.TrimPrefix(strings.TrimSpace(string(out)), "Client Version: v"))
 	if err != nil {
 
 		return false, err
 	}
 
-	v2, err := version.NewVersion("1.18.0")
+	v2, err := constraint.NewVersion("1.18.0")
 	if err != nil {
 		return false, err
 	}

…b.com/hashicorp/go-version/constraint.go pkg/util/constraint/constraint.govendor/github.com/hashicorp/go-version/constraint.go renamed to pkg/util/constraint/constraint.go vendor/github.com/hashicorp/go-version/constraint.go renamed to pkg/util/constraint/constraint.go

@@ -1,40 +1,51 @@
-package version
+package constraint
 
 import (
 	"fmt"
 	"reflect"
 	"regexp"
+	"sort"
 	"strings"
 )
 
 // Constraint represents a single constraint for a version, such as
 // ">= 1.0".
 type Constraint struct {
 	f        constraintFunc
+	op       operator
 	check    *Version
 	original string
 }
 
+func (c *Constraint) Equals(con *Constraint) bool {
+	return c.op == con.op && c.check.Equal(con.check)
+}
+
 // Constraints is a slice of constraints. We make a custom type so that
 // we can add methods to it.
 type Constraints []*Constraint
 
 type constraintFunc func(v, c *Version) bool
 
-var constraintOperators map[string]constraintFunc
+var constraintOperators map[string]constraintOperation
+
+type constraintOperation struct {
+	op operator
+	f  constraintFunc
+}
 
 var constraintRegexp *regexp.Regexp
 
 func init() {
-	constraintOperators = map[string]constraintFunc{
-		"":   constraintEqual,
-		"=":  constraintEqual,
-		"!=": constraintNotEqual,
-		">":  constraintGreaterThan,
-		"<":  constraintLessThan,
-		">=": constraintGreaterThanEqual,
-		"<=": constraintLessThanEqual,
-		"~>": constraintPessimistic,
+	constraintOperators = map[string]constraintOperation{
+		"":   {op: equal, f: constraintEqual},
+		"=":  {op: equal, f: constraintEqual},
+		"!=": {op: notEqual, f: constraintNotEqual},
+		">":  {op: greaterThan, f: constraintGreaterThan},
+		"<":  {op: lessThan, f: constraintLessThan},
+		">=": {op: greaterThanEqual, f: constraintGreaterThanEqual},
+		"<=": {op: lessThanEqual, f: constraintLessThanEqual},
+		"~>": {op: pessimistic, f: constraintPessimistic},
 	}
 
 	ops := make([]string, 0, len(constraintOperators))
@@ -63,7 +74,7 @@ func NewConstraint(v string) (Constraints, error) {
 		result[i] = c
 	}
 
-	return Constraints(result), nil
+	return result, nil
 }
 
 // Check tests if a version satisfies all the constraints.
@@ -77,6 +88,56 @@ func (cs Constraints) Check(v *Version) bool {
 	return true
 }
 
+// Equals compares Constraints with other Constraints
+// for equality. This may not represent logical equivalence
+// of compared constraints.
+// e.g. even though '>0.1,>0.2' is logically equivalent
+// to '>0.2' it is *NOT* treated as equal.
+//
+// Missing operator is treated as equal to '=', whitespaces
+// are ignored and constraints are sorted before comparison.
+func (cs Constraints) Equals(c Constraints) bool {
+	if len(cs) != len(c) {
+		return false
+	}
+
+	// make copies to retain order of the original slices
+	left := make(Constraints, len(cs))
+	copy(left, cs)
+	sort.Stable(left)
+	right := make(Constraints, len(c))
+	copy(right, c)
+	sort.Stable(right)
+
+	// compare sorted slices
+	for i, con := range left {
+		if !con.Equals(right[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (cs Constraints) Len() int {
+	return len(cs)
+}
+
+func (cs Constraints) Less(i, j int) bool {
+	if cs[i].op < cs[j].op {
+		return true
+	}
+	if cs[i].op > cs[j].op {
+		return false
+	}
+
+	return cs[i].check.LessThan(cs[j].check)
+}
+
+func (cs Constraints) Swap(i, j int) {
+	cs[i], cs[j] = cs[j], cs[i]
+}
+
 // Returns the string format of the constraints
 func (cs Constraints) String() string {
 	csStr := make([]string, len(cs))
@@ -99,16 +160,19 @@ func (c *Constraint) String() string {
 func parseSingle(v string) (*Constraint, error) {
 	matches := constraintRegexp.FindStringSubmatch(v)
 	if matches == nil {
-		return nil, fmt.Errorf("Malformed constraint: %s", v)
+		return nil, fmt.Errorf("malformed constraint: %s", v)
 	}
 
 	check, err := NewVersion(matches[2])
 	if err != nil {
 		return nil, err
 	}
 
+	cop := constraintOperators[matches[1]]
+
 	return &Constraint{
-		f:        constraintOperators[matches[1]],
+		f:        cop.f,
+		op:       cop.op,
 		check:    check,
 		original: v,
 	}, nil
@@ -122,10 +186,7 @@ func prereleaseCheck(v, c *Version) bool {
 		return reflect.DeepEqual(c.Segments64(), v.Segments64())
 
 	case !cPre && vPre:
-		// A constraint without a pre-release can only match a version without a
-		// pre-release.
-		return false
-
+		// OK
 	case cPre && !vPre:
 		// OK, except with the pessimistic operator
 	case !cPre && !vPre:
@@ -138,6 +199,18 @@ func prereleaseCheck(v, c *Version) bool {
 // Constraint functions
 //-------------------------------------------------------------------
 
+type operator rune
+
+const (
+	equal            operator = '='
+	notEqual         operator = '≠'
+	greaterThan      operator = '>'
+	lessThan         operator = '<'
+	greaterThanEqual operator = '≥'
+	lessThanEqual    operator = '≤'
+	pessimistic      operator = '~'
+)
+
 func constraintEqual(v, c *Version) bool {
 	return v.Equal(c)
 }
@@ -195,10 +268,5 @@ func constraintPessimistic(v, c *Version) bool {
 	// Check the last part of the segment in the constraint. If the version segment at
 	// this index is less than the constraints segment at this index, then it cannot
 	// be valid against the constraint
-	if c.segments[cs-1] > v.segments[cs-1] {
-		return false
-	}
-
-	// If nothing has rejected the version by now, it's valid
-	return true
+	return c.segments[cs-1] <= v.segments[cs-1]
 }