[licensor]: refactor evaluators into a single evaluator

The previous Gitpod and Replicated evaluators were functionally
identical anyway as all the logic happens in the constructors

Author: Simon Emms

components/licensor/ee/cmd/validate.go

@@ -25,7 +25,7 @@ var validateCmd = &cobra.Command{
 		domain, _ := cmd.Flags().GetString("domain")
 		licensorType, _ := cmd.Flags().GetString("licensor")
 
-		var e licensor.Evaluator
+		var e *licensor.Evaluator
 		switch licensorType {
 		case string(licensor.LicenseTypeReplicated):
 			e = licensor.NewReplicatedEvaluator(domain)

components/licensor/ee/pkg/licensor/gitpod.go

@@ -14,73 +14,31 @@ import (
 	"time"
 )
 
-// GitpodEvaluator determines what a license allows for
-type GitpodEvaluator struct {
-	invalid string
-	lic     LicensePayload
-}
-
-// Validate returns false if the license isn't valid and a message explaining why that is.
-func (e *GitpodEvaluator) Validate() (msg string, valid bool) {
-	if e.invalid == "" {
-		return "", true
-	}
-
-	return e.invalid, false
-}
-
-// Enabled determines if a feature is enabled by the license
-func (e *GitpodEvaluator) Enabled(feature Feature) bool {
-	if e.invalid != "" {
-		return false
-	}
-
-	_, ok := e.lic.Level.allowance().Features[feature]
-	return ok
-}
-
-// HasEnoughSeats returns true if the license supports at least the give amount of seats
-func (e *GitpodEvaluator) HasEnoughSeats(seats int) bool {
-	if e.invalid != "" {
-		return false
-	}
-
-	return e.lic.Seats == 0 || seats <= e.lic.Seats
-}
-
-// Inspect returns the license information this evaluator holds.
-// This function is intended for transparency/debugging purposes only and must
-// never be used to determine feature eligibility under a license. All code making
-// those kinds of decisions must be part of the Evaluator.
-func (e *GitpodEvaluator) Inspect() LicensePayload {
-	return e.lic
-}
-
 // NewGitpodEvaluator produces a new license evaluator from a license key
-func NewGitpodEvaluator(key []byte, domain string) (res *GitpodEvaluator) {
+func NewGitpodEvaluator(key []byte, domain string) (res *Evaluator) {
 	if len(key) == 0 {
 		// fallback to the default license
-		return &GitpodEvaluator{
+		return &Evaluator{
 			lic: defaultLicense,
 		}
 	}
 
 	deckey := make([]byte, base64.StdEncoding.DecodedLen(len(key)))
 	n, err := base64.StdEncoding.Decode(deckey, key)
 	if err != nil {
-		return &GitpodEvaluator{invalid: fmt.Sprintf("cannot decode key: %q", err)}
+		return &Evaluator{invalid: fmt.Sprintf("cannot decode key: %q", err)}
 	}
 	deckey = deckey[:n]
 
 	var lic licensePayload
 	err = json.Unmarshal(deckey, &lic)
 	if err != nil {
-		return &GitpodEvaluator{invalid: fmt.Sprintf("cannot unmarshal key: %q", err)}
+		return &Evaluator{invalid: fmt.Sprintf("cannot unmarshal key: %q", err)}
 	}
 
 	keyWoSig, err := json.Marshal(lic.LicensePayload)
 	if err != nil {
-		return &GitpodEvaluator{invalid: fmt.Sprintf("cannot remarshal key: %q", err)}
+		return &Evaluator{invalid: fmt.Sprintf("cannot remarshal key: %q", err)}
 	}
 	hashed := sha256.Sum256(keyWoSig)
 
@@ -91,18 +49,18 @@ func NewGitpodEvaluator(key []byte, domain string) (res *GitpodEvaluator) {
 		}
 	}
 	if err != nil {
-		return &GitpodEvaluator{invalid: fmt.Sprintf("cannot verify key: %q", err)}
+		return &Evaluator{invalid: fmt.Sprintf("cannot verify key: %q", err)}
 	}
 
 	if !matchesDomain(lic.Domain, domain) {
-		return &GitpodEvaluator{invalid: "wrong domain"}
+		return &Evaluator{invalid: "wrong domain"}
 	}
 
 	if lic.ValidUntil.Before(time.Now()) {
-		return &GitpodEvaluator{invalid: "not valid anymore"}
+		return &Evaluator{invalid: "not valid anymore"}
 	}
 
-	return &GitpodEvaluator{
+	return &Evaluator{
 		lic: lic.LicensePayload,
 	}
 }

components/licensor/ee/pkg/licensor/licensor.go

@@ -140,11 +140,46 @@ func matchesDomain(pattern, domain string) bool {
 	return false
 }
 
-type Evaluator interface {
-	Enabled(feature Feature) bool
-	HasEnoughSeats(seats int) bool
-	Inspect() LicensePayload
-	Validate() (msg string, valid bool)
+// Evaluator determines what a license allows for
+type Evaluator struct {
+	invalid string
+	lic     LicensePayload
+}
+
+// Validate returns false if the license isn't valid and a message explaining why that is.
+func (e *Evaluator) Validate() (msg string, valid bool) {
+	if e.invalid == "" {
+		return "", true
+	}
+
+	return e.invalid, false
+}
+
+// Enabled determines if a feature is enabled by the license
+func (e *Evaluator) Enabled(feature Feature) bool {
+	if e.invalid != "" {
+		return false
+	}
+
+	_, ok := e.lic.Level.allowance().Features[feature]
+	return ok
+}
+
+// HasEnoughSeats returns true if the license supports at least the give amount of seats
+func (e *Evaluator) HasEnoughSeats(seats int) bool {
+	if e.invalid != "" {
+		return false
+	}
+
+	return e.lic.Seats == 0 || seats <= e.lic.Seats
+}
+
+// Inspect returns the license information this evaluator holds.
+// This function is intended for transparency/debugging purposes only and must
+// never be used to determine feature eligibility under a license. All code making
+// those kinds of decisions must be part of the Evaluator.
+func (e *Evaluator) Inspect() LicensePayload {
+	return e.lic
 }
 
 // Sign signs a license so that it can be used with the evaluator

components/licensor/ee/pkg/licensor/licensor_test.go

@@ -25,7 +25,7 @@ const (
 type licenseTest struct {
 	Name         string
 	License      *LicensePayload
-	Validate     func(t *testing.T, eval Evaluator)
+	Validate     func(t *testing.T, eval *Evaluator)
 	Type         LicenseType
 	NeverExpires bool
 }
@@ -47,7 +47,7 @@ func newTestClient(fn roundTripFunc) *http.Client {
 
 func (test *licenseTest) Run(t *testing.T) {
 	t.Run(test.Name, func(t *testing.T) {
-		var eval Evaluator
+		var eval *Evaluator
 		if test.Type == LicenseTypeGitpod {
 			if test.NeverExpires {
 				t.Fatal("gitpod licenses must have an expiry date")
@@ -195,7 +195,7 @@ func TestSeats(t *testing.T) {
 				Seats:      test.Licensed,
 				ValidUntil: validUntil,
 			},
-			Validate: func(t *testing.T, eval Evaluator) {
+			Validate: func(t *testing.T, eval *Evaluator) {
 				withinLimits := eval.HasEnoughSeats(test.Probe)
 				if withinLimits != test.WithinLimits {
 					t.Errorf("HasEnoughSeats did not behave as expected: lic=%d probe=%d expected=%v actual=%v", test.Licensed, test.Probe, test.WithinLimits, withinLimits)
@@ -253,7 +253,7 @@ func TestFeatures(t *testing.T) {
 		lt := licenseTest{
 			Name:    test.Name,
 			License: lic,
-			Validate: func(t *testing.T, eval Evaluator) {
+			Validate: func(t *testing.T, eval *Evaluator) {
 				unavailableFeatures := featureSet{}
 				for f := range allowanceMap[LevelEnterprise].Features {
 					unavailableFeatures[f] = struct{}{}

components/licensor/ee/pkg/licensor/replicated.go

@@ -69,24 +69,24 @@ func (e *ReplicatedEvaluator) Validate() (msg string, valid bool) {
 }
 
 // defaultReplicatedLicense this is the default license if call fails
-func defaultReplicatedLicense() *ReplicatedEvaluator {
-	return &ReplicatedEvaluator{
+func defaultReplicatedLicense() *Evaluator {
+	return &Evaluator{
 		lic: defaultLicense,
 	}
 }
 
 // newReplicatedEvaluator exists to allow mocking of client
-func newReplicatedEvaluator(client *http.Client, domain string) (res *ReplicatedEvaluator) {
+func newReplicatedEvaluator(client *http.Client, domain string) (res *Evaluator) {
 	resp, err := client.Get(replicatedLicenseApiEndpoint)
 	if err != nil {
-		return &ReplicatedEvaluator{invalid: fmt.Sprintf("cannot query kots admin, %q", err)}
+		return &Evaluator{invalid: fmt.Sprintf("cannot query kots admin, %q", err)}
 	}
 	defer resp.Body.Close()
 
 	var replicatedPayload replicatedLicensePayload
 	err = json.NewDecoder(resp.Body).Decode(&replicatedPayload)
 	if err != nil {
-		return &ReplicatedEvaluator{invalid: fmt.Sprintf("cannot decode json data, %q", err)}
+		return &Evaluator{invalid: fmt.Sprintf("cannot decode json data, %q", err)}
 	}
 
 	lic := LicensePayload{
@@ -119,12 +119,12 @@ func newReplicatedEvaluator(client *http.Client, domain string) (res *Replicated
 		}
 	}
 
-	return &ReplicatedEvaluator{
+	return &Evaluator{
 		lic: lic,
 	}
 }
 
 // NewReplicatedEvaluator gets the license data from the kots admin panel
-func NewReplicatedEvaluator(domain string) (res *ReplicatedEvaluator) {
+func NewReplicatedEvaluator(domain string) (res *Evaluator) {
 	return newReplicatedEvaluator(&http.Client{Timeout: replicatedLicenseApiTimeout}, domain)
 }

components/licensor/typescript/ee/main.go

@@ -15,7 +15,7 @@ import (
 )
 
 var (
-	instances map[int]licensor.Evaluator = make(map[int]licensor.Evaluator)
+	instances map[int]*licensor.Evaluator = make(map[int]*licensor.Evaluator)
 	nextID    int                        = 1
 )