[licensor]: introduce concept of a fallback license with limited features

The Enabled function now has knowledge of the number of seats in use. If
this is still within range, the features are checked against the loaded
license. If not, they will be checked against the fallback license.

The fallback is optional, based upon the license type - Gitpod licenses
always disable fallback. Replicated licenses disable fallback if it's a
paid license. This is so paying customers aren't inconvenienced by
losing features - instead, they will be unable to add additional users,
as is the current behaviour.

Author: Simon Emms

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

@@ -61,6 +61,7 @@ func NewGitpodEvaluator(key []byte, domain string) (res *Evaluator) {
 	}
 
 	return &Evaluator{
-		lic: lic.LicensePayload,
+		lic:           lic.LicensePayload,
+		allowFallback: false, // Gitpod licenses cannot fallback - assume these are always paid-for
 	}
 }

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

@@ -117,9 +117,18 @@ func (lvl LicenseLevel) allowance() allowance {
 	return a
 }
 
+// Fallback license is used when the instance exceeds the number of licenses - it allows limited access
+var fallbackLicense = LicensePayload{
+	ID:    "fallback-license",
+	Level: LevelTeam,
+	Seats: 0,
+	// Domain, ValidUntil are free for all
+}
+
+// Default license is used when no valid license is given - it allows full access up to 10 users
 var defaultLicense = LicensePayload{
 	ID:    "default-license",
-	Level: LevelTeam,
+	Level: LevelEnterprise,
 	Seats: 10,
 	// Domain, ValidUntil are free for all
 }
@@ -144,8 +153,9 @@ func matchesDomain(pattern, domain string) bool {
 
 // Evaluator determines what a license allows for
 type Evaluator struct {
-	invalid string
-	lic     LicensePayload
+	invalid       string
+	allowFallback bool // Paid licenses cannot fallback and prevent additional signups
+	lic           LicensePayload
 }
 
 // Validate returns false if the license isn't valid and a message explaining why that is.
@@ -158,24 +168,45 @@ func (e *Evaluator) Validate() (msg string, valid bool) {
 }
 
 // Enabled determines if a feature is enabled by the license
-func (e *Evaluator) Enabled(feature Feature) bool {
+func (e *Evaluator) Enabled(feature Feature, seats int) bool {
 	if e.invalid != "" {
 		return false
 	}
 
-	_, ok := e.lic.Level.allowance().Features[feature]
+	var ok bool
+	if e.hasEnoughSeats(seats) {
+		// License has enough seats available - evaluate this license
+		_, ok = e.lic.Level.allowance().Features[feature]
+	} else if e.allowFallback {
+		// License has run out of seats - use the fallback license
+		_, ok = fallbackLicense.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 {
+// 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
 }
 
+// HasEnoughSeats is the public method to hasEnoughSeats. Will use fallback license if allowable
+func (e *Evaluator) HasEnoughSeats(seats int) bool {
+	if e.invalid != "" {
+		return false
+	}
+
+	if !e.allowFallback {
+		return e.hasEnoughSeats(seats)
+	}
+	// There is always more space if can use a fallback license
+	return true
+}
+
 // 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

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

@@ -23,11 +23,12 @@ const (
 )
 
 type licenseTest struct {
-	Name         string
-	License      *LicensePayload
-	Validate     func(t *testing.T, eval *Evaluator)
-	Type         LicenseType
-	NeverExpires bool
+	Name                  string
+	License               *LicensePayload
+	Validate              func(t *testing.T, eval *Evaluator)
+	Type                  LicenseType
+	NeverExpires          bool
+	ReplicatedLicenseType *ReplicatedLicenseType
 }
 
 // roundTripFunc .
@@ -76,6 +77,12 @@ func (test *licenseTest) Run(t *testing.T) {
 				}
 
 				payload, err := json.Marshal(replicatedLicensePayload{
+					LicenseType: func() ReplicatedLicenseType {
+						if test.ReplicatedLicenseType == nil {
+							return ReplicatedLicenseTypePaid
+						}
+						return *test.ReplicatedLicenseType
+					}(),
 					ExpirationTime: func() *time.Time {
 						if test.License != nil {
 							return &test.License.ValidUntil
@@ -96,15 +103,6 @@ func (test *licenseTest) Run(t *testing.T) {
 								return domain
 							}(),
 						},
-						{
-							Field: "levelId",
-							Value: func() LicenseLevel {
-								if test.License != nil {
-									return test.License.Level
-								}
-								return LevelTeam
-							}(),
-						},
 						{
 							Field: "seats",
 							Value: func() int {
@@ -196,9 +194,9 @@ func TestSeats(t *testing.T) {
 				ValidUntil: validUntil,
 			},
 			Validate: func(t *testing.T, eval *Evaluator) {
-				withinLimits := eval.HasEnoughSeats(test.Probe)
+				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)
+					t.Errorf("hasEnoughSeats did not behave as expected: lic=%d probe=%d expected=%v actual=%v", test.Licensed, test.Probe, test.WithinLimits, withinLimits)
 				}
 			},
 			Type:         test.LicenseType,
@@ -212,31 +210,78 @@ func TestSeats(t *testing.T) {
 }
 
 func TestFeatures(t *testing.T) {
+	replicatedCommunity := ReplicatedLicenseTypeCommunity
+	replicatedPaid := ReplicatedLicenseTypePaid
+
 	tests := []struct {
-		Name           string
-		DefaultLicense bool
-		Level          LicenseLevel
-		Features       []Feature
-		LicenseType    LicenseType
+		Name                  string
+		DefaultLicense        bool
+		Level                 LicenseLevel
+		Features              []Feature
+		LicenseType           LicenseType
+		UserCount             int
+		ReplicatedLicenseType *ReplicatedLicenseType
 	}{
-		{"Gitpod: no license", true, LicenseLevel(0), []Feature{FeaturePrebuild, FeatureAdminDashboard}, LicenseTypeGitpod},
-		{"Gitpod: invalid license level", false, LicenseLevel(666), []Feature{}, LicenseTypeGitpod},
-		{"Gitpod: enterprise license", false, LevelEnterprise, []Feature{
+		{"Gitpod (in seats): no license", true, LicenseLevel(0), []Feature{
+			FeatureAdminDashboard,
+			FeatureSetTimeout,
+			FeatureWorkspaceSharing,
+			FeatureSnapshot,
+			FeaturePrebuild,
+		}, LicenseTypeGitpod, 10, nil},
+		{"Gitpod (in seats): invalid license level", false, LicenseLevel(666), []Feature{}, LicenseTypeGitpod, seats, nil},
+		{"Gitpod (in seats): enterprise license", false, LevelEnterprise, []Feature{
 			FeatureAdminDashboard,
 			FeatureSetTimeout,
 			FeatureWorkspaceSharing,
 			FeatureSnapshot,
 			FeaturePrebuild,
-		}, LicenseTypeGitpod},
+		}, LicenseTypeGitpod, seats, nil},
+
+		{"Gitpod (over seats): no license", true, LicenseLevel(0), []Feature{
+			FeaturePrebuild,
+		}, LicenseTypeGitpod, 11, nil},
+		{"Gitpod (over seats): invalid license level", false, LicenseLevel(666), []Feature{}, LicenseTypeGitpod, seats + 1, nil},
+		{"Gitpod (over seats): enterprise license", false, LevelEnterprise, []Feature{}, LicenseTypeGitpod, seats + 1, nil},
 
-		{"Replicated: invalid license level", false, LicenseLevel(666), []Feature{}, LicenseTypeReplicated},
-		{"Replicated: enterprise license", false, LevelEnterprise, []Feature{
+		{"Replicated (in seats): invalid license level", false, LicenseLevel(666), []Feature{
 			FeatureAdminDashboard,
 			FeatureSetTimeout,
 			FeatureWorkspaceSharing,
 			FeatureSnapshot,
 			FeaturePrebuild,
-		}, LicenseTypeReplicated},
+		}, LicenseTypeReplicated, seats, &replicatedPaid},
+		{"Replicated (in seats): enterprise license", false, LevelEnterprise, []Feature{
+			FeatureAdminDashboard,
+			FeatureSetTimeout,
+			FeatureWorkspaceSharing,
+			FeatureSnapshot,
+			FeaturePrebuild,
+		}, LicenseTypeReplicated, seats, &replicatedPaid},
+
+		{"Replicated (over seats - no fallback): invalid license level", true, LicenseLevel(666), []Feature{
+			FeatureAdminDashboard,
+			FeatureSetTimeout,
+			FeatureWorkspaceSharing,
+			FeatureSnapshot,
+			FeaturePrebuild,
+		}, LicenseTypeReplicated, seats + 1, &replicatedPaid},
+		{"Replicated (over seats - no fallback): enterprise license", true, LevelEnterprise, []Feature{
+			FeatureAdminDashboard,
+			FeatureSetTimeout,
+			FeatureWorkspaceSharing,
+			FeatureSnapshot,
+			FeaturePrebuild,
+		}, LicenseTypeReplicated, seats + 1, &replicatedPaid},
+
+		{"Replicated (over seats - fallback): invalid license level", false, LicenseLevel(666), []Feature{
+			FeatureAdminDashboard,
+			FeaturePrebuild,
+		}, LicenseTypeReplicated, seats + 1, &replicatedCommunity},
+		{"Replicated (over seats - fallback): enterprise license", false, LevelEnterprise, []Feature{
+			FeatureAdminDashboard,
+			FeaturePrebuild,
+		}, LicenseTypeReplicated, seats + 1, &replicatedCommunity},
 	}
 
 	for _, test := range tests {
@@ -251,8 +296,9 @@ func TestFeatures(t *testing.T) {
 			lic = nil
 		}
 		lt := licenseTest{
-			Name:    test.Name,
-			License: lic,
+			Name:                  test.Name,
+			License:               lic,
+			ReplicatedLicenseType: test.ReplicatedLicenseType,
 			Validate: func(t *testing.T, eval *Evaluator) {
 				unavailableFeatures := featureSet{}
 				for f := range allowanceMap[LevelEnterprise].Features {
@@ -261,13 +307,13 @@ func TestFeatures(t *testing.T) {
 				for _, f := range test.Features {
 					delete(unavailableFeatures, f)
 
-					if !eval.Enabled(f) {
+					if !eval.Enabled(f, test.UserCount) {
 						t.Errorf("license does not enable %s, but should", f)
 					}
 				}
 
 				for f := range unavailableFeatures {
-					if eval.Enabled(f) {
+					if eval.Enabled(f, test.UserCount) {
 						t.Errorf("license not enables %s, but shouldn't", f)
 					}
 				}

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

@@ -23,15 +23,25 @@ type replicatedFields struct {
 	Value interface{} `json:"value"` // This is of type "fieldType"
 }
 
+type ReplicatedLicenseType string
+
+// variable names are what Replicated calls them in the vendor portal
+const (
+	ReplicatedLicenseTypeCommunity   ReplicatedLicenseType = "community"
+	ReplicatedLicenseTypeDevelopment ReplicatedLicenseType = "dev"
+	ReplicatedLicenseTypePaid        ReplicatedLicenseType = "prod"
+	ReplicatedLicenseTypeTrial       ReplicatedLicenseType = "trial"
+)
+
 // replicatedLicensePayload exists to convert the JSON structure to a LicensePayload
 type replicatedLicensePayload struct {
-	LicenseID      string             `json:"license_id"`
-	InstallationID string             `json:"installation_id"`
-	Assignee       string             `json:"assignee"`
-	ReleaseChannel string             `json:"release_channel"`
-	LicenseType    string             `json:"license_type"`
-	ExpirationTime *time.Time         `json:"expiration_time,omitempty"` // Not set if license never expires
-	Fields         []replicatedFields `json:"fields"`
+	LicenseID      string                `json:"license_id"`
+	InstallationID string                `json:"installation_id"`
+	Assignee       string                `json:"assignee"`
+	ReleaseChannel string                `json:"release_channel"`
+	LicenseType    ReplicatedLicenseType `json:"license_type"`
+	ExpirationTime *time.Time            `json:"expiration_time,omitempty"` // Not set if license never expires
+	Fields         []replicatedFields    `json:"fields"`
 }
 
 type ReplicatedEvaluator struct {
@@ -90,7 +100,8 @@ func newReplicatedEvaluator(client *http.Client, domain string) (res *Evaluator)
 	}
 
 	lic := LicensePayload{
-		ID: replicatedPayload.LicenseID,
+		ID:    replicatedPayload.LicenseID,
+		Level: LevelEnterprise,
 	}
 
 	// Search for the fields
@@ -99,9 +110,6 @@ func newReplicatedEvaluator(client *http.Client, domain string) (res *Evaluator)
 		case "domain":
 			lic.Domain = i.Value.(string)
 
-		case "levelId":
-			lic.Level = LicenseLevel(i.Value.(float64))
-
 		case "seats":
 			lic.Seats = int(i.Value.(float64))
 		}
@@ -120,7 +128,8 @@ func newReplicatedEvaluator(client *http.Client, domain string) (res *Evaluator)
 	}
 
 	return &Evaluator{
-		lic: lic,
+		lic:           lic,
+		allowFallback: replicatedPayload.LicenseType == ReplicatedLicenseTypeCommunity, // Only community licenses are allowed to fallback
 	}
 }
 

components/licensor/typescript/ee/main.go

@@ -16,7 +16,7 @@ import (
 
 var (
 	instances map[int]*licensor.Evaluator = make(map[int]*licensor.Evaluator)
-	nextID    int                        = 1
+	nextID    int                         = 1
 )
 
 // Init initializes the global license evaluator from an environment variable
@@ -49,13 +49,13 @@ func Validate(id int) (msg *C.char, valid bool) {
 
 // Enabled returns true if a license enables a feature
 //export Enabled
-func Enabled(id int, feature *C.char) (enabled, ok bool) {
+func Enabled(id int, feature *C.char, seats int) (enabled, ok bool) {
 	e, ok := instances[id]
 	if !ok {
 		return
 	}
 
-	return e.Enabled(licensor.Feature(C.GoString(feature))), true
+	return e.Enabled(licensor.Feature(C.GoString(feature)), seats), true
 }
 
 // HasEnoughSeats returns true if the license supports at least the given number of seats.

components/licensor/typescript/ee/src/index.ts

@@ -49,8 +49,8 @@ export class LicenseEvaluator {
         return { msg: v.msg, valid: false };
     }
 
-    public isEnabled(feature: Feature): boolean {
-        return isEnabled(this.instanceID, feature);
+    public isEnabled(feature: Feature, seats: number): boolean {
+        return isEnabled(this.instanceID, feature, seats);
     }
 
     public hasEnoughSeats(seats: number): boolean {