@futdevpro/nts-dynamo 1.6.19 → 1.6.21

package/src/_services/server/app-extended.server.ts

@@ -2,12 +2,13 @@
 import * as SocketIO from 'socket.io';
 import * as Http from 'http';
 
-import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { delay, Dynamo_Array, Dynamo_Error, Dynamo_Log, second, wait } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_App } from './app.server';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DynamoNTS_SocketServerService } from '../socket/socket-server.service';
 import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
+import { DynamoNTS_AppExtSysControls } from '../../_models/control-models/app-system-controls.control-model copy';
 
 /**
  * This will be the MAIN service of our server project,
@@ -110,8 +111,15 @@ import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
  * }
  */
 export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
+  
+  private systemControlsExt: DynamoNTS_AppExtSysControls = new DynamoNTS_AppExtSysControls();
+  override get started(): boolean { return this.systemControlsExt.appExtended.started; }
+  private httpsSocketCount: number = 0;
+  private httpSocketCount: number = 0;
 
   private socketSecurity: DynamoNTS_RouteSecurity;
+
+  private httpSocketServer: Http.Server;
   
   /**
    * @example
@@ -123,27 +131,147 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
    * ];
    */
   protected socketServices: DynamoNTS_SocketServerService<any>[];
+  private allSocketServers: SocketIO.Server[] = [];
 
   constructor(){
-    super();
+    super(true);
+
+    this.asyncConstructExt();
+  }
 
+  private async asyncConstructExt(): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. asyncConstruct-extended');
     try {
+      this.systemControlsExt.appExtended.init = true;
+    
       this.socketServices = this.getSocketServices();
 
       if (this.socketServices?.length) {
         this.setSocketSecurity();
 
-        this.setupSocketServerServices();
-
-        if (this.debugLog) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
+        await this.setupSocketServerServices();
+        if (this.logSetup) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
       } else {
-        Dynamo_Log.warn(
+        Dynamo_Log.testWarn(
           '\nNo socketServices setted up while using Extended Application.',
           '\nYou should use DynamoNTS_App if you don`t need socket services.\n' 
         );
       }
+
+      await this.ready();
+      
+      Dynamo_Log.test(`${this.params.name} started successfully.`);
     } catch (error) {
-      Dynamo_Log.error('\nExtended Application start failed.\n', error, '\n');
+      Dynamo_Log.error(`\nExtended Application: ${this.params?.name} start failed.\n`, error, '\n');
+    }
+  }
+
+  override async ready(timeout: number = 4 * second): Promise<void> {
+    if (this.logFn) console.log('\nfn:. ready-extended');
+    await super.ready(timeout);
+
+    let ready: boolean = false;
+    const start: number = +new Date();
+
+    if (this.constructErrors.length) {
+      Dynamo_Log.error(`Extended Application: ${this.params?.name} start failed. ERRORS`, this.constructErrors, '\n');
+      throw new Dynamo_Error({ 
+        message: `${this.params?.name} start failed. ERRORS`,
+        additionalContent: this.constructErrors,
+        error: this.constructErrors?.[0] ?? new Error()
+      });
+    }
+
+    while (!ready && +new Date() - start < timeout) {
+      if (this.systemControlsExt.appExtended.init) {
+        ready = (
+          this.superStarted &&
+          this.systemControlsExt.httpSocketServer.getReady() &&
+          this.systemControlsExt.httpsSocketServer.getReady()
+        );
+      }
+
+      await wait(100);
+    }
+
+    if (this.constructErrors.length) {
+      Dynamo_Log.error(`Extended Application: ${this.params?.name} start failed. TIMEOUT`, this.constructErrors, '\n');
+      throw new Dynamo_Error({ 
+        message: `${this.params?.name} start failed. TIMEOUT`,
+        additionalContent: this.constructErrors,
+        error: this.constructErrors?.[0] ?? new Error()
+      });
+    }
+
+    if (ready) {
+      this.systemControlsExt.appExtended.started = true;
+      
+      if (this.logFn && this.deepLog) console.log('\nfn:. ready-extended: return');
+      return;
+    } else {
+      this.systemControlsExt.appExtended.started = false;
+      
+      let msg: string = `${this.params?.name} start failed. UNKNOWN`;
+      if (this.systemControlsExt.httpSocketServer.init && !this.systemControlsExt.httpSocketServer.started) {
+        msg += '\nhttpSocketServer start failed.';
+      }
+      if (this.systemControlsExt.httpsSocketServer.init && !this.systemControlsExt.httpsSocketServer.started) {
+        msg += '\nhttpsSocketServer start failed.';
+      }      
+
+      Dynamo_Log.error(msg, this.constructErrors, '\n');
+      throw new Dynamo_Error({ 
+        errorCode: 'NTS-AES-110',
+        message: msg,
+        additionalContent: {
+          constructErrors: this.constructErrors,
+          systemControls: this.systemControls,
+          systemControlsExt: this.systemControlsExt,
+          systemReadies: {
+            app: this.systemControls.app.getReady(),
+            appExtended: this.systemControlsExt.appExtended.getReady(),
+            mongoose: this.systemControls.mongoose.getReady(),
+            httpServer: this.systemControls.httpServer.getReady(),
+            httpsServer: this.systemControls.httpsServer.getReady(),
+            httpSocketServer: this.systemControlsExt.httpSocketServer.getReady(),
+            httpsSocketServer: this.systemControlsExt.httpsSocketServer.getReady(),
+          },
+        },
+        error: this.constructErrors?.[0] ?? new Error()
+      });
+    }
+  }
+
+  override async stop(): Promise<void> {
+    if (this.logFn) console.log('\nfn:. stop-extended');
+    if (this.started) {
+      await super.stop(true);
+
+      this.systemControlsExt.httpSocketServer.started = false;
+      this.systemControlsExt.httpsSocketServer.started = false;
+      await Dynamo_Array.asyncForEach(this.allSocketServers, async (socketServer: SocketIO.Server) => {
+        await new Promise<void>((resolve, reject) => {
+          socketServer.disconnectSockets(true);
+          socketServer.close((err) => {
+            if (err) {
+              Dynamo_Log.error(`\nHTTP socket server close error`, err);
+              reject(
+                new Dynamo_Error({
+                  errorCode: 'NTS-AES-120',
+                  message: `SocketServer close failed.`,
+                  error: err
+                })
+              );
+            } else {
+              resolve();
+            }
+          });
+        });
+      });
+      this.systemControlsExt.httpSocketServer.init = false;
+      this.systemControlsExt.httpsSocketServer.init = false;
+
+      Dynamo_Log.test(`${this.params.name} stopped successfully.`);
     }
   }
 
@@ -151,6 +279,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
    * 
    */
   private setSocketSecurity(): void {
+    if (this.logFn) console.log('\nfn:. setSocketSecurity');
     this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
       if (!this.socketSecurity) {
         this.socketSecurity = DynamoNTS_RouteSecurity[service.security];
@@ -163,20 +292,23 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
   /**
    * 
    */
-  private setupSocketServerServices(): void {
+  private async setupSocketServerServices(): Promise<void> {
     try {
-      let httpSocketServer: Http.Server;
+      if (this.logFn) console.log('\nfn:. setupSocketServerServices');
+      /* let httpServer: Http.Server; */
       if (this.socketSecurity !== DynamoNTS_RouteSecurity.secure) {
         if (!this.openExpress) {
-          this.initOpenExpress();
+          await this.initOpenExpress();
+        }
+        if (!this.httpSocketServer) {
+          this.httpSocketServer = Http.createServer(this.openExpress);
         }
-        httpSocketServer = Http.createServer(this.openExpress);
       }
 
       if (this.socketSecurity !== DynamoNTS_RouteSecurity.open) {
         if (!this.httpsServer) {
           if (this.cert) {
-            this.initSecureExpress();
+            await this.initSecureExpress();
           } else {
             let errorMsg: string =
               `\nYou have secure socket service, but the certification paths are not set!` +
@@ -190,7 +322,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
             errorMsg += '\n\nThe socket services setted to use secure server:';
             this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
               if (service.security != DynamoNTS_SocketSecurity.open) {
-                errorMsg += `\n  ${service.name} (port: ${service.port})`;
+                errorMsg += `\n  ${service?.name} (port: ${service.port})`;
               }
             });
             Dynamo_Log.error(errorMsg);
@@ -205,42 +337,74 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
         }
       }
 
-      this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
-        try {
-          const existingPorts: DynamoNTS_SocketServerService<any>[] = this.socketServices.filter(
-            (mod: DynamoNTS_SocketServerService<any>) => mod.port === service.port
-          );
+      await Dynamo_Array.asyncForEach(
+        this.socketServices, 
+        async (service: DynamoNTS_SocketServerService<any>) => {
+          try {
+            this.systemControlsExt.httpSocketServer.init = true;
+            const existingPorts: DynamoNTS_SocketServerService<any>[] = this.socketServices.filter(
+              (mod: DynamoNTS_SocketServerService<any>) => mod.port === service.port
+            );
 
-          if (1 < existingPorts.length || this.ports.httpPort === service.port || this.ports.httpsPort === service.port) {
-            let error = new Error(`PORT DUPLICATION: ${service.port}`);
-            let errorStack: string[] = error.stack.split('\n');
-            errorStack.splice(1, 4);
-            error.stack = errorStack.join('\n');
+            if (1 < existingPorts.length || this.ports.httpPort === service.port || this.ports.httpsPort === service.port) {
+              let error = new Error(`PORT DUPLICATION: ${service.port}`);
+              let errorStack: string[] = error.stack.split('\n');
+              errorStack.splice(1, 4);
+              error.stack = errorStack.join('\n');
 
-            throw error;
-          }
+              throw error;
+            }
 
-          if (service.security === DynamoNTS_SocketSecurity.open) {
-            if (this.debugLog) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
-            service.setupSocketServer(new SocketIO.Server(httpSocketServer));
+            if (service.security === DynamoNTS_SocketSecurity.open) {
+              if (this.logSetup) console.log(`\nsocket setup (open): ${service?.name}:${service.port}`);
+              this.httpSocketCount++;
+              this.systemControlsExt.httpSocketServer.started = false;
 
-          } else if (service.security === DynamoNTS_SocketSecurity.secure) {
-            if (this.debugLog) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
-            service.setupSocketServer(new SocketIO.Server(this.httpsServer));
-            
-          } else {
-            let error = new Error(`INVALID Socket Service security: ${service.security} on ${service.name}`);
-            let errorStack: string[] = error.stack.split('\n');
-            errorStack.splice(1, 4);
-            error.stack = errorStack.join('\n');
+              this.allSocketServers.push(
+                await service.setupSocketServer(
+                  new SocketIO.Server(this.httpSocketServer), 
+                  DynamoNTS_SocketSecurity.open, 
+                  () => { 
+                    this.httpSocketCount--;
+                    if (this.httpSocketCount === 0) {
+                      this.systemControlsExt.httpSocketServer.started = true;
+                    }
+                  }
+                )
+              );
+
+            } else if (service.security === DynamoNTS_SocketSecurity.secure) {
+              if (this.logSetup) console.log(`\nsocket setup (secure): ${service?.name}:${service.port}`);
+              this.httpsSocketCount++;
+              this.systemControlsExt.httpsSocketServer.started = false;
 
+              this.allSocketServers.push(
+                await service.setupSocketServer(
+                  new SocketIO.Server(this.httpsServer), 
+                  DynamoNTS_SocketSecurity.secure, 
+                  () => {
+                    this.httpsSocketCount--;
+                    if (this.httpsSocketCount === 0) {
+                      this.systemControlsExt.httpsSocketServer.started = true;
+                    }
+                  }
+                )
+              );
+              
+            } else {
+              let error = new Error(`INVALID Socket Service security: ${service.security} on ${service?.name}`);
+              let errorStack: string[] = error.stack.split('\n');
+              errorStack.splice(1, 4);
+              error.stack = errorStack.join('\n');
+
+              throw error;
+            }
+          } catch (error) {
+            Dynamo_Log.error(`\nSocket Server service setup failed. (${service?.name})\n`, error, '\n');
             throw error;
           }
-        } catch (error) {
-          Dynamo_Log.error(`\nSocket Server service setup failed. (${service.name})\n`, error, '\n');
-          throw error;
         }
-      });
+      );
     } catch (error) {
       Dynamo_Log.error(`\nSocket Server services setup failed. (${this.socketServices?.length} services)\n`, error, '\n');
       throw error;

package/src/_services/server/app.server.spec.ts

@@ -1,14 +1,21 @@
 
-import { delay } from '@futdevpro/fsm-dynamo';
+import { delay, Dynamo_Log, second } from '@futdevpro/fsm-dynamo';
+import { DynamoNTS_AppExtendedBase_Mock, DynamoNTS_AppExtendedFull_Mock } from '../../_constants/mocks/app-extended-server.mock';
 import { DynamoNTS_AppBase_Mock, DynamoNTS_AppFull_Mock } from '../../_constants/mocks/app-server.mock';
 
-describe('DynamoNTS_App;', () => {
+describe('DynamoNTS_App AND DynamoNTS_AppExtended?;', () => {
+  // jasmine.DEFAULT_TIMEOUT_INTERVAL = 15 * second;
+
   describe('a base instance;', () => {
     let app: DynamoNTS_AppBase_Mock;
 
     beforeEach(async () => {
-      app = new DynamoNTS_AppBase_Mock();
-      await app.ready();
+      try {
+        app = new DynamoNTS_AppBase_Mock();
+        await app.ready();
+      } catch (error) {
+        Dynamo_Log.test('error', error);
+      }
     });
 
     afterEach(async () => {
@@ -28,8 +35,12 @@ describe('DynamoNTS_App;', () => {
     let app: DynamoNTS_AppFull_Mock;
 
     beforeEach(async () => {
-      app = new DynamoNTS_AppFull_Mock();
-      await app.ready();
+      try {
+        app = new DynamoNTS_AppFull_Mock();
+        await app.ready();
+      } catch (error) {
+        Dynamo_Log.test('error', error);
+      }
     });
 
     afterEach(async () => {
@@ -43,7 +54,6 @@ describe('DynamoNTS_App;', () => {
     it('should be started', () => {
       expect(app.started).toBeTrue();
     });
-
   });
 });