BACKEND DONE FOR ALL APPS

2024-10-21 18:34:45 +03:00
parent 4157ca9e7d
commit ab1eaec413
349 changed files with 17199 additions and 14015 deletions
@@ -0,0 +1,155 @@
+import { Worker } from 'worker_threads';
+import path from 'path';
+import {WindowManager} from "./window_manager";
+
+export class WorkerManager {
+    private readonly pathToWorkerDir: string;
+    private windowManager: WindowManager
+    private workers: Worker[]; // Array to store running workers
+
+    constructor(pathToWorkerDir: string, windowManager: WindowManager) {
+        this.pathToWorkerDir = pathToWorkerDir;
+        this.windowManager = windowManager;
+        this.workers = []; // Initialize the array to store workers
+    }
+
+    // Start the Connection Pool Worker
+    async startWatchersWorker(memoryManagerPath: string, applicationInfoPath: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(path.join(this.pathToWorkerDir, 'watcher_worker.js'), {
+                workerData: { memoryManagerPath, applicationInfoPath },  // Pass the port to the worker
+            });
+
+            this.workers.push(worker); // Store the worker reference
+
+            worker.on('message', (data) => {
+                console.log('Connection Pool Worker message:', data);
+            });
+
+            worker.on('error', (err) => {
+                console.error('Connection Pool Worker error:', err);
+                worker.terminate();
+                this.removeWorker(worker);
+                reject(err); // Reject the promise if there's an error
+            });
+
+            worker.on('exit', (code) => {
+                console.log(`Connection Pool Worker exited with code ${code}`);
+                this.removeWorker(worker); // Remove worker reference when it exits
+                resolve(); // Resolve when the worker exits cleanly
+            });
+        });
+    }
+
+    // Start the Servers Worker (UDP and TCP servers)
+    async startServersWorker(host: string, udpPort: number, tcpPort: number): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(path.join(this.pathToWorkerDir, 'servers_worker.js'), {
+                workerData: { HOST: host, USER_UDP_PORT: udpPort, USER_TCP_PORT: tcpPort },  // Pass host and ports to the worker
+            });
+
+            this.workers.push(worker); // Store the worker reference
+
+            worker.on('message', (data) => {
+                console.log('Servers Worker message:', data);
+            });
+
+            worker.on('error', (err) => {
+                console.error('Servers Worker error:', err);
+                worker.terminate();
+                this.removeWorker(worker);
+                reject(err); // Reject the promise if there's an error
+            });
+
+            worker.on('exit', (code) => {
+                console.log(`Servers Worker exited with code ${code}`);
+                this.removeWorker(worker); // Remove worker reference when it exits
+                resolve(); // Resolve when the worker exits cleanly
+            });
+        });
+    }
+
+    // Start the Users Info Worker
+    async startResourceCoordinatorWorker(usersConfigPath: string, applicationInfoPath: string, memoryManagerPath: string, queueManagerPath: string, tcpPort: number): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(path.join(this.pathToWorkerDir, 'resource_coordinator_worker.js'), {
+                workerData: {
+                    usersConfigPath,
+                    applicationInfoPath,
+                    memoryManagerPath,
+                    queueManagerPath,
+                    tcpPort
+                }, // Pass necessary parameters to the worker
+            });
+
+            this.workers.push(worker); // Store the worker reference
+
+            worker.on('message', (data) => {
+                console.log('Users Info Worker message:', data);
+            });
+
+            worker.on('error', (err) => {
+                console.error('Users Info Worker error:', err);
+                worker.terminate();
+                this.removeWorker(worker);
+                reject(err); // Reject the promise if there's an error
+            });
+
+            worker.on('exit', (code) => {
+                console.log(`Users Info Worker exited with code ${code}`);
+                this.removeWorker(worker); // Remove worker reference when it exits
+                resolve(); // Resolve when the worker exits cleanly
+            });
+        });
+    }
+
+    // Start the Backup Retrieval Worker
+    async startBackupRetrievalWorker(
+        userConfigPath: string,
+        applicationInfoPath: string,
+        clientPort: number,
+        destinationPath: string
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(path.join(this.pathToWorkerDir, 'backup_retrieval_worker.js'), {
+                workerData: { userConfigPath, applicationInfoPath, clientPort, destinationPath },  // Pass parameters to the worker
+            });
+
+            this.workers.push(worker); // Store the worker reference
+
+            worker.on('message', (data) => {
+                console.log('Backup Retrieval Worker message:', data);
+                this.windowManager.changeContent('main_menu');
+                this.windowManager.showAlert(data.message);
+            });
+
+            worker.on('error', (err) => {
+                console.error('Backup Retrieval Worker error:', err);
+                worker.terminate();
+                this.removeWorker(worker);
+                reject(err); // Reject the promise if there's an error
+            });
+
+            worker.on('exit', (code) => {
+                console.log(`Backup Retrieval Worker exited with code ${code}`);
+                this.removeWorker(worker); // Remove worker reference when it exits
+                resolve(); // Resolve when the worker exits cleanly
+            });
+        });
+    }
+
+    // Close all running workers
+    closeAllWorkers(): void {
+        console.log('Terminating all running workers...');
+        this.workers.forEach(worker => worker.terminate()); // Terminate each worker
+        this.workers = []; // Clear the array after terminating all workers
+    }
+
+    // Helper method to remove a worker from the workers array when it exits
+    private removeWorker(worker: Worker): void {
+        const index = this.workers.indexOf(worker);
+        if (index > -1) {
+            this.workers.splice(index, 1); // Remove the worker from the array
+        }
+    }
+}