network chunk v20

CEO/src/helpers/department_sharer.ts

@@ -14,6 +14,8 @@ export class DepartmentSharer {
     private readonly clientPort: number;
     private isBusy: boolean = false;
     private tcpCommunicator: TcpCommunicator | null = null;
+    private stopRequested: boolean = false;
+    private intervalId: NodeJS.Timeout | null = null;
 
     constructor(
         userConfigPath: string,
@@ -30,12 +32,16 @@ export class DepartmentSharer {
 
     // Start sharing files with the department every minute
     async start(): Promise<void> {
-        setInterval(async () => {
-            if (!this.isBusy) {
+        this.intervalId = setInterval(async () => {
+            if (!this.isBusy || !this.stopRequested) {
                 this.isBusy = true;
                 this.log('Start successfully. Sharing files with the department.');
                 await this.shareFilesWithDepartment();
             }
+
+            if (global.gc) {
+                global.gc();
+            }
         }, 10000);  // 10-second interval for testing
     }
 
@@ -87,11 +93,10 @@ export class DepartmentSharer {
                 const userIp = user.ip;
                 this.tcpCommunicator = new TcpCommunicator(userIp, this.clientPort);
 
-                if (await this.tcpCommunicator.connect()) continue;
+                if (!await this.tcpCommunicator.connect()) continue;
 
-                // First clear the department directory
-                const clearSuccess = await this.clearDepartmentDirectory();
-                if (clearSuccess) {
+                // First clear the department directory;
+                if (await this.clearDepartmentDirectory(userName)) {
                     await this.sendFilesToUser(departmentFiles.structure, userName);
                 }
 
@@ -108,10 +113,10 @@ export class DepartmentSharer {
     }
 
     // Clear the department directory for a user
-    private async clearDepartmentDirectory(): Promise<boolean> {
+    private async clearDepartmentDirectory(userName: string): Promise<boolean> {
         if(!this.tcpCommunicator) return false;
 
-        if (!await this.tcpCommunicator.sendMessage(operationCodes.CLEAR_DEPARTMENT)) return false;
+        if (!await this.tcpCommunicator.sendMessage(operationCodes.CLEAR_DEPARTMENT, {userName: userName})) return false;
         const response = await this.waitForResponse();
 
         if (!response || response.operationCode !== operationCodes.OK){
@@ -127,6 +132,8 @@ export class DepartmentSharer {
         if(!this.tcpCommunicator) return;
         const unsentFiles = Object.keys(files);
 
+        console.log(`\n\n${unsentFiles}\n\n`);
+
         for (const fileName of unsentFiles) {
             const filePath = files[fileName];
 
@@ -152,17 +159,37 @@ export class DepartmentSharer {
             // Send the file
             if (!await this.tcpCommunicator.sendMessage(operationCodes.DEPARTMENT_FILE, metaInfo, Buffer.from(fileContent))) return;
 
+            console.log(`\n\nSending file: ${fileName} to ${userName}\n\n`);
+
             const response = await this.waitForResponse();
             if (!response || response.operationCode !== operationCodes.OK) {
                 this.log(`Failed to send file: ${fileName}`, 'error');
                 return;
             }
 
+            this.log(`File sent successfully: ${fileName} to ${userName}`);
+
             unsentFiles.splice(unsentFiles.indexOf(fileName), 1);
             await this.tcpCommunicator.disconnect();
         }
     }
 
+    async stop(): Promise<void> {
+        this.stopRequested = true; // Signal that stop is requested
+
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+
+        // Wait for any ongoing process to complete if busy
+        while (this.isBusy) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+
+        console.log("[BackupManager] Stopped successfully.");
+    }
+
     private async waitForResponse(): Promise<ParsedMessage | null> {
         return new Promise((resolve) => {
             const idResponseCheck = setInterval(async () => {