src/core/ServiceManager.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { lstatSync } from "fs";
import { readdir } from "fs/promises";
import { join } from "path";
import { log, logInfo, logWarn } from "../utils/logger";
import Client from "./Client";
import Service from "./Service";

type LoadServiceOptions = {
    extensionName?: string;
    serviceAliasName?: string;
    log?: boolean;
};

export default class ServiceManager {
    constructor(protected client: Client) {}

    async loadServices() {
        for (const service of this.client.services) {
            let replacedService = service;

            for (const alias in this.client.aliases) {
                replacedService = replacedService.replace(alias, this.client.aliases[alias as keyof typeof this.client.aliases]);
            }

            await this.loadService(replacedService);
        }
    }

    async loadService(servicePath: string, { extensionName, serviceAliasName, log = true }: LoadServiceOptions = {}) {
        const { default: Service, name } = await import(servicePath);
        const wasPreviouslyLoaded = this.wasPreviouslyLoaded(name);
        const finalName = extensionName ?? serviceAliasName ?? name;

        if (log) {
            logInfo(`${wasPreviouslyLoaded ? "Rel" : "L"}oading service: `, finalName);
        }

        const serviceInstance = new Service(this.client);
        this.client[name as "services"] = serviceInstance;
        this.client.loadEventListenersFromMetadata(Service, serviceInstance);
        await this.serviceLifeCycle(serviceInstance, wasPreviouslyLoaded, finalName);
    }

    wasPreviouslyLoaded(name: string) {
        return this.client[name as "services"] instanceof Service;
    }

    async deactivateService(name: string) {
        if (!(this.client[name as "services"] instanceof Service)) {
            return;
        }

        logInfo("Deactivated service: ", name);
        await (this.client[name as "services"] as any)?.deactivate();
        this.client[name as "services"] = {} as any;
    }

    async serviceLifeCycle(serviceInstance: Service, wasPreviouslyLoaded: boolean, finalName: string) {
        if (wasPreviouslyLoaded) {
            await serviceInstance.deactivate();
        }

        if (!wasPreviouslyLoaded) {
            await serviceInstance.boot();
        }

        await serviceInstance.reboot();

        if (wasPreviouslyLoaded) {
            await serviceInstance.rebootNext();
        }
    }

    async loadServiceFromFile(path: string, extension?: string) {
        const {
            default: Service,
            name
        }: {
            name?: string;
            default: new (client: Client) => Service;
        } = await import(path);

        if (!name && extension) {
            logWarn(
                `Extension ${extension} has attempted to load a service that does not export a \`name\` constant. (file: ${path})`
            );
            return false;
        }

        const wasPreviouslyLoaded = !!this.client[name as "services"];
        const finalName = extension ? `${extension}:@services/${name}` : `@services/${name ?? path}`;

        logInfo("Loading service: ", finalName);

        const service = new Service(this.client);

        this.client[name as "services"] = service as any;
        this.client.loadEventListenersFromMetadata(Service, service);

        await this.serviceLifeCycle(service, wasPreviouslyLoaded, name ?? path);
        return true;
    }

    async loadServiceFromDirectory(path: string) {
        const files = await readdir(path);

        for (const file of files) {
            const filePath = join(path, file);

            if (lstatSync(filePath).isDirectory()) {
                await this.loadServiceFromDirectory(filePath);
                continue;
            }

            if (file.endsWith(".d.ts")) {
                continue;
            }

            if (file.endsWith(".js") || file.endsWith(".ts")) {
                log("Attempting to load service from file: ", filePath);
                await this.loadServiceFromFile(filePath);
            }
        }
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { lstatSync } from "fs";
21			import { readdir } from "fs/promises";
22			import { join } from "path";
23			import { log, logInfo, logWarn } from "../utils/logger";
24			import Client from "./Client";
25			import Service from "./Service";
26
27			type LoadServiceOptions = {
28			extensionName?: string;
29			serviceAliasName?: string;
30			log?: boolean;
31			};
32
33			export default class ServiceManager {
34			constructor(protected client: Client) {}
35
36			async loadServices() {
37			for (const service of this.client.services) {
38			let replacedService = service;
39
40			for (const alias in this.client.aliases) {
41			replacedService = replacedService.replace(alias, this.client.aliases[alias as keyof typeof this.client.aliases]);
42			}
43
44			await this.loadService(replacedService);
45			}
46			}
47
48			async loadService(servicePath: string, { extensionName, serviceAliasName, log = true }: LoadServiceOptions = {}) {
49			const { default: Service, name } = await import(servicePath);
50			const wasPreviouslyLoaded = this.wasPreviouslyLoaded(name);
51			const finalName = extensionName ?? serviceAliasName ?? name;
52
53			if (log) {
54			logInfo(`${wasPreviouslyLoaded ? "Rel" : "L"}oading service: `, finalName);
55			}
56
57			const serviceInstance = new Service(this.client);
58			this.client[name as "services"] = serviceInstance;
59			this.client.loadEventListenersFromMetadata(Service, serviceInstance);
60			await this.serviceLifeCycle(serviceInstance, wasPreviouslyLoaded, finalName);
61			}
62
63			wasPreviouslyLoaded(name: string) {
64			return this.client[name as "services"] instanceof Service;
65			}
66
67			async deactivateService(name: string) {
68			if (!(this.client[name as "services"] instanceof Service)) {
69			return;
70			}
71
72			logInfo("Deactivated service: ", name);
73			await (this.client[name as "services"] as any)?.deactivate();
74			this.client[name as "services"] = {} as any;
75			}
76
77			async serviceLifeCycle(serviceInstance: Service, wasPreviouslyLoaded: boolean, finalName: string) {
78			if (wasPreviouslyLoaded) {
79			await serviceInstance.deactivate();
80			}
81
82			if (!wasPreviouslyLoaded) {
83			await serviceInstance.boot();
84			}
85
86			await serviceInstance.reboot();
87
88			if (wasPreviouslyLoaded) {
89			await serviceInstance.rebootNext();
90			}
91			}
92
93			async loadServiceFromFile(path: string, extension?: string) {
94			const {
95			default: Service,
96			name
97			}: {
98			name?: string;
99			default: new (client: Client) => Service;
100			} = await import(path);
101
102			if (!name && extension) {
103			logWarn(
104			`Extension ${extension} has attempted to load a service that does not export a \`name\` constant. (file: ${path})`
105			);
106			return false;
107			}
108
109			const wasPreviouslyLoaded = !!this.client[name as "services"];
110			const finalName = extension ? `${extension}:@services/${name}` : `@services/${name ?? path}`;
111
112			logInfo("Loading service: ", finalName);
113
114			const service = new Service(this.client);
115
116			this.client[name as "services"] = service as any;
117			this.client.loadEventListenersFromMetadata(Service, service);
118
119			await this.serviceLifeCycle(service, wasPreviouslyLoaded, name ?? path);
120			return true;
121			}
122
123			async loadServiceFromDirectory(path: string) {
124			const files = await readdir(path);
125
126			for (const file of files) {
127			const filePath = join(path, file);
128
129			if (lstatSync(filePath).isDirectory()) {
130			await this.loadServiceFromDirectory(filePath);
131			continue;
132			}
133
134			if (file.endsWith(".d.ts")) {
135			continue;
136			}
137
138			if (file.endsWith(".js") \|\| file.endsWith(".ts")) {
139			log("Attempting to load service from file: ", filePath);
140			await this.loadServiceFromFile(filePath);
141			}
142			}
143			}
144			}