feat: License v3 validations

RocketChat · Oct 3, 2023 · 5b24b16 · 5b24b16
1 parent 3fd0bc4
commit 5b24b16
Show file tree

Hide file tree

Showing 10 changed files with 226 additions and 52 deletions.
diff --git a/apps/meteor/ee/app/license/server/startup.ts b/apps/meteor/ee/app/license/server/startup.ts
@@ -1,3 +1,4 @@
+import { cronJobs } from '@rocket.chat/cron';
 import { License } from '@rocket.chat/license';
 import { Subscriptions, Users } from '@rocket.chat/models';
 
@@ -26,3 +27,19 @@ License.setLicenseLimitCounter('privateApps', () => getAppCount('private'));
 License.setLicenseLimitCounter('marketplaceApps', () => getAppCount('marketplace'));
 // #TODO: Get real value
 License.setLicenseLimitCounter('monthlyActiveContacts', async () => 0);
+
+const updateCronJob = async () => {
+	if (License.hasValidLicense() === (await cronJobs.has('licenseLimitChecker'))) {
+		return;
+	}
+
+	if (License.hasValidLicense()) {
+		await cronJobs.add('licenseLimitChecker', '*/30 * * * *', () => License.revalidateLimits());
+	} else {
+		await cronJobs.remove('licenseLimitChecker');
+	}
+};
+
+License.onValidateLicense(async () => updateCronJob());
+License.onInvalidateLicense(async () => updateCronJob());
+void updateCronJob();
diff --git a/ee/packages/license/src/definition/LicenseBehavior.ts b/ee/packages/license/src/definition/LicenseBehavior.ts
@@ -1,6 +1,12 @@
 import type { LicenseModule } from './LicenseModule';
 
-export type LicenseBehavior = 'invalidate_license' | 'start_fair_policy' | 'prevent_action' | 'prevent_installation' | 'disable_modules';
+export type LicenseBehavior =
+	| 'invalidate_license'
+	| 'start_fair_policy'
+	| 'prevent_action'
+	| 'prevent_installation'
+	| 'disable_modules'
+	| 'custom';
 
 export type BehaviorWithContext = {
 	behavior: LicenseBehavior;

diff --git a/ee/packages/license/src/events/emitter.ts b/ee/packages/license/src/events/emitter.ts
@@ -1,4 +1,5 @@
 import type { LicenseLimitKind } from '../definition/ILicenseV3';
+import type { LicenseBehavior } from '../definition/LicenseBehavior';
 import type { LicenseModule } from '../definition/LicenseModule';
 import type { LicenseManager } from '../license';
 import { logger } from '../logger';
@@ -21,10 +22,31 @@ export function moduleRemoved(this: LicenseManager, module: LicenseModule) {
 	}
 }
 
-export function limitReached(this: LicenseManager, limitKind: LicenseLimitKind) {
+export function limitReached(
+	this: LicenseManager,
+	limitKind: Exclude<LicenseLimitKind, 'roomsPerGuest'>,
+	limitBehavior: Exclude<LicenseBehavior, 'prevent_installation'>,
+) {
 	try {
-		this.emit(`limitReached:${limitKind}`);
+		// This will never be emitted for limits that fallback to "not reached" when missing context params (eg: roomsPerGuest)
+		this.emit(`limitReached:${limitKind}:${limitBehavior}`);
 	} catch (error) {
 		logger.error({ msg: 'Error running limit reached event', error });
 	}
 }
+
+export function licenseValidated(this: LicenseManager) {
+	try {
+		this.emit('validate');
+	} catch (error) {
+		logger.error({ msg: 'Error running license validated event', error });
+	}
+}
+
+export function licenseInvalidated(this: LicenseManager) {
+	try {
+		this.emit('invalidate');
+	} catch (error) {
+		logger.error({ msg: 'Error running license invalidated event', error });
+	}
+}
diff --git a/ee/packages/license/src/events/listeners.ts b/ee/packages/license/src/events/listeners.ts
@@ -1,4 +1,5 @@
 import type { LicenseLimitKind } from '../definition/ILicenseV3';
+import type { LicenseBehavior } from '../definition/LicenseBehavior';
 import type { LicenseModule } from '../definition/LicenseModule';
 import type { LicenseManager } from '../license';
 import { hasModule } from '../modules';
@@ -58,18 +59,23 @@ export function onToggledFeature(
 	};
 }
 
-export function onModule(this: LicenseManager, cb: (...args: any[]) => void) {
+export function onModule(this: LicenseManager, cb: (data: { module: LicenseModule; valid: boolean }) => void) {
 	this.on('module', cb);
 }
 
-export function onValidateLicense(this: LicenseManager, cb: (...args: any[]) => void) {
+export function onValidateLicense(this: LicenseManager, cb: () => void) {
 	this.on('validate', cb);
 }
 
-export function onInvalidateLicense(this: LicenseManager, cb: (...args: any[]) => void) {
+export function onInvalidateLicense(this: LicenseManager, cb: () => void) {
 	this.on('invalidate', cb);
 }
 
-export function onLimitReached(this: LicenseManager, limitKind: LicenseLimitKind, cb: (...args: any[]) => void) {
-	this.on(`limitReached:${limitKind}`, cb);
+export function onLimitReached(
+	this: LicenseManager,
+	limitKind: Exclude<LicenseLimitKind, 'roomsPerGuest'>,
+	cb: () => void,
+	limitBehavior: Exclude<LicenseBehavior, 'prevent_installation'> = 'custom',
+) {
+	this.on(`limitReached:${limitKind}:${limitBehavior}`, cb);
 }
diff --git a/ee/packages/license/src/index.ts b/ee/packages/license/src/index.ts
@@ -1,4 +1,5 @@
 import type { ILicenseV3, LicenseLimitKind } from './definition/ILicenseV3';
+import type { LicenseBehavior } from './definition/LicenseBehavior';
 import type { LicenseModule } from './definition/LicenseModule';
 import type { LimitContext } from './definition/LimitContext';
 import { getAppsConfig, getMaxActiveUsers, getUnmodifiedLicenseAndModules } from './deprecated';
@@ -37,14 +38,20 @@ interface License {
 	overwriteClassOnLicense: typeof overwriteClassOnLicense;
 	setLicenseLimitCounter: typeof setLicenseLimitCounter;
 	getCurrentValueForLicenseLimit: typeof getCurrentValueForLicenseLimit;
-	isLimitReached: <T extends LicenseLimitKind>(action: T, context?: Partial<LimitContext<T>>) => Promise<boolean>;
+	isLimitReached: <T extends LicenseLimitKind>(
+		action: T,
+		behaviors: LicenseBehavior[],
+		context?: Partial<LimitContext<T>>,
+	) => Promise<boolean>;
 	onValidFeature: typeof onValidFeature;
 	onInvalidFeature: typeof onInvalidFeature;
 	onToggledFeature: typeof onToggledFeature;
 	onModule: typeof onModule;
 	onValidateLicense: typeof onValidateLicense;
 	onInvalidateLicense: typeof onInvalidateLicense;
 	onLimitReached: typeof onLimitReached;
+	revalidateLicense: () => Promise<void>;
+	revalidateLimits: () => Promise<void>;
 
 	getInfo: (loadCurrentValues: boolean) => Promise<{
 		license: ILicenseV3 | undefined;
@@ -78,8 +85,12 @@ export class LicenseImp extends LicenseManager implements License {
 
 	getCurrentValueForLicenseLimit = getCurrentValueForLicenseLimit;
 
-	public async isLimitReached<T extends LicenseLimitKind>(action: T, context?: Partial<LimitContext<T>>) {
-		return this.shouldPreventAction(action, context, 0);
+	public async isLimitReached<T extends LicenseLimitKind>(
+		action: T,
+		behaviors: LicenseBehavior[],
+		context?: Partial<LimitContext<T>>,
+	): Promise<boolean> {
+		return super.isLimitReached(action, behaviors, context);
 	}
 
 	onValidFeature = onValidFeature;