Move service shutdown logic to each service

Author: sampaiodiego

apps/meteor/ee/app/license/server/license.internalService.ts

@@ -1,4 +1,3 @@
-import { debounce } from 'underscore';
 import type { ILicense } from '@rocket.chat/core-services';
 import { api, ServiceClassInternal } from '@rocket.chat/core-services';
 
@@ -24,54 +23,6 @@ export class LicenseService extends ServiceClassInternal implements ILicense {
 		onModule((licenseModule) => {
 			api.broadcast('license.module', licenseModule);
 		});
-
-		/**
-		 * The main idea is if there is no scalability module enabled,
-		 * then we should not allow more than one service per environment.
-		 * So we list the services and nodes, and if there is more than
-		 * one, we inform the service that it should be disabled.
-		 */
-		const shutdownServices = debounce(async () => {
-			if (hasLicense('scalability')) {
-				return;
-			}
-
-			const services: {
-				name: string;
-				nodes: string[];
-			}[] = await api.call('$node.services');
-
-			// Filter only the duplicated services
-			const duplicated = services.filter((service) => {
-				return service.name !== '$node' && service.nodes.length > 1;
-			});
-
-			if (!duplicated.length) {
-				return;
-			}
-
-			const brokers: Record<string, string[]> = Object.fromEntries(
-				duplicated.map((service) => {
-					// remove the first node from the list
-					const [, ...nodes] = service.nodes;
-					return [service.name, nodes];
-				}),
-			);
-
-			const duplicatedServicesNames = duplicated.map((service) => service.name);
-
-			// send shutdown signal to the duplicated services
-			api.broadcastToServices(duplicatedServicesNames, 'shutdown', brokers);
-		}, 1000);
-
-		this.onEvent('$services.changed', async ({ localService }) => {
-			// since this is an internal service, we can ignore this event if the service that triggered is a local service.
-			// this will also prevent race conditions if a license is not in place when this process is starting up.
-			if (localService) {
-				return;
-			}
-			shutdownServices();
-		});
 	}
 
 	async started(): Promise<void> {

apps/meteor/ee/server/NetworkBroker.ts

@@ -2,6 +2,8 @@ import type { ServiceBroker, Context, ServiceSchema } from 'moleculer';
 import { asyncLocalStorage } from '@rocket.chat/core-services';
 import type { IBroker, IBrokerNode, IServiceMetrics, IServiceClass, EventSignatures } from '@rocket.chat/core-services';
 
+import { EnterpriseCheck } from './lib/EnterpriseCheck';
+
 const events: { [k: string]: string } = {
 	onNodeConnected: '$node.connected',
 	onNodeUpdated: '$node.updated',
@@ -90,17 +92,6 @@ export class NetworkBroker implements IBroker {
 			return;
 		}
 
-		if (!instance.isInternal()) {
-			instance.onEvent('shutdown', async (services) => {
-				if (!services[name]?.includes(this.broker.nodeID)) {
-					this.broker.logger.info({ msg: 'Not shutting down, different node.', nodeID: this.broker.nodeID });
-					return;
-				}
-				this.broker.logger.warn({ msg: 'Received shutdown event, destroying service.', nodeID: this.broker.nodeID });
-				this.destroyService(instance);
-			});
-		}
-
 		const instanceEvents = instance.getEvents();
 		if (!instanceEvents && !methods.length) {
 			return;
@@ -111,6 +102,7 @@ export class NetworkBroker implements IBroker {
 		const service: ServiceSchema = {
 			name,
 			actions: {},
+			mixins: !instance.isInternal() ? [EnterpriseCheck] : [],
 			...dependencies,
 			events: instanceEvents.reduce<Record<string, (ctx: Context) => void>>((map, eventName) => {
 				map[eventName] = /^\$/.test(eventName)

apps/meteor/ee/server/lib/EnterpriseCheck.ts

@@ -0,0 +1,58 @@
+import type { ServiceSchema } from 'moleculer';
+
+const { LICENSE_CHECK_INTERVAL = '20', MAX_FAILS = '2' } = process.env;
+
+let checkFails = 0;
+const maxFails = parseInt(MAX_FAILS) || 2;
+
+export const EnterpriseCheck: ServiceSchema = {
+	name: 'EnterpriseCheck',
+	methods: {
+		/**
+		 * The main idea is if there is no scalability module enabled,
+		 * then we should not allow more than one service per environment.
+		 * So we list the services and nodes, and if there is more than
+		 * one, we say it should be shutdown.
+		 */
+		async shouldShutdown(): Promise<boolean> {
+			const services: {
+				name: string;
+				nodes: string[];
+			}[] = await this.broker.call('$node.services');
+
+			const currentService = services.find((service) => {
+				return service.name === this.name;
+			});
+
+			// if current service is not on the list maybe it is already shut down?
+			if (!currentService) {
+				return true;
+			}
+
+			const { nodes } = currentService;
+
+			const firstNode = nodes.sort().shift();
+
+			// if the first node is the current node and there are others nodes running the same service, then it should shutdown
+			return firstNode === this.broker.nodeID && nodes.length > 0;
+		},
+	},
+	async started(): Promise<void> {
+		setInterval(async () => {
+			const hasLicense = await this.broker.call('license.hasLicense', ['scalability']);
+			if (hasLicense) {
+				checkFails = 0;
+				return;
+			}
+
+			if (++checkFails < maxFails) {
+				return;
+			}
+
+			const shouldShutdown = await this.shouldShutdown();
+			if (shouldShutdown) {
+				this.broker.fatal('Enterprise license not found. Shutting down...');
+			}
+		}, (parseInt(LICENSE_CHECK_INTERVAL) || 20) * 1000);
+	},
+};