@futdevpro/nts-dynamo 1.6.18 → 1.6.19

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

@@ -1,11 +1,12 @@
 
 import Mongoose = require("mongoose");
 import Express = require("express");
+import * as Http from 'http';
 import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { delay, Dynamo_Array, Dynamo_Error, Dynamo_Log, second } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
@@ -177,6 +178,15 @@ import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-
 export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
   started: boolean = false;
+  private initDone: boolean = false;
+  private haveMongoose: boolean = false;
+  private mongooseStarted: boolean = false;
+  private haveHttpServer: boolean = false;
+  private httpServerStarted: boolean = false;
+  private haveHttpsServer: boolean = false;
+  private httpsServerStarted: boolean = false;
+  private constructErrors: (Error | Dynamo_Error)[] = [];
+
   get serverName(): string { return this.params.name; }
 
   private _params: DynamoNTS_AppParams;
@@ -196,6 +206,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   protected openExpress: Express.Application;
   private secureExpress: Express.Application;
   protected httpsServer: Https.Server;
+  protected httpServer: Http.Server;
+
+  private globalService: DynamoNTS_GlobalService;
 
   private _routingModules: DynamoNTS_RoutingModule[] = [];
   /* protected get routingModules(): DynamoNTS_RoutingModule[] { return this._routingModules; } */
@@ -217,6 +230,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         this.overrideDynamoNTSGlobalSettings();        
       } 
       
+      this.globalService = DynamoNTS_GlobalService.getInstance();
       DynamoNTS_GlobalService.setServices(this.getGlobalServiceCollection());
       DynamoNTS_GlobalService.setParams(this.params);
 
@@ -273,21 +287,119 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         this.postProcess();
       }
 
-      this.started = true;
+      this.initDone = true;
+      this.ready();
     } catch (error) {
+      this.constructErrors.push(error);
       Dynamo_Log.error('\nApplication start failed.\n', error);
     }
   }
 
+  async ready(timeout: number = 4 * second): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      let ready: boolean = false;
+      const start: number = +new Date();
+
+      if (this.constructErrors.length) {
+        reject({ 
+          message: 'Application start failed. TIMEOUT',
+          errors: this.constructErrors
+        });
+      }
+
+      while (!ready && +new Date() - start < timeout) {
+        await delay(100);
+
+        if (this.initDone) {
+          ready = (
+            this.haveMongoose ? this.mongooseStarted : true &&
+            this.haveHttpServer ? this.httpServerStarted : true &&
+            this.haveHttpsServer ? this.httpsServerStarted : true
+          );
+        }
+      }
+
+      if (this.constructErrors.length) {
+        reject({ 
+          message: 'Application start failed. TIMEOUT',
+          errors: this.constructErrors
+        });
+      }
+
+      if (ready) {
+        this.started = true;
+        
+        resolve();
+      } else {
+        this.started = false;
+        
+        let msg: string = 'Application start failed. TIMEOUT';
+        if (this.haveMongoose && !this.mongooseStarted) {
+          msg += '\nMongoose start failed.';
+        }
+        if (this.haveHttpServer && !this.httpServerStarted) {
+          msg += '\nHTTP Server start failed.';
+        }
+        if (this.haveHttpsServer && !this.httpsServerStarted) {
+          msg += '\nHTTPS Server start failed.';
+        }
+
+        
+
+        reject({ 
+          message: 'Application start failed. TIMEOUT',
+          errors: this.constructErrors
+        });
+      }
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.started) {
+
+      if (this.haveHttpServer) {
+        await new Promise((resolve) => {
+          this.httpServer.close(resolve);
+        });
+      }
+      if (this.haveHttpsServer) {
+        await new Promise((resolve) => {
+          this.httpsServer.close(resolve);
+        });
+      }
+      if (this.haveMongoose) {
+        await Dynamo_Array.asyncForEach(Object.keys(this.mongoose.models), async (modelName) => {
+          await this.mongoose.deleteModel(modelName);
+        });
+        await this.mongoose.disconnect();
+      }
+      
+      this.initDone = false;
+      this.haveHttpServer = false;
+      this.haveHttpsServer = false;
+      this.haveMongoose = false;
+      this.mongooseStarted = false;
+      this.httpServerStarted = false;
+      this.httpsServerStarted = false;
+      this.started = false;
+
+      Dynamo_Log.success('\nServer stopped.\n');
+    }
+  }
+
   /**
    * 
    */
   private startDB(): void {
+    this.haveMongoose = true;
     this.mongoose.connection
       .on('error', (error) => {
+        this.mongooseStarted = false;
+        this.constructErrors.push(error);
         Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
       })
       .once('open', () => {
+        this.mongooseStarted = true;
         Dynamo_Log.success('\nConnected to MongoDB\n');
       });
 
@@ -403,11 +515,15 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   private async startExpresses(): Promise<void> {
     try {
       if (this._security && this._security !== DynamoNTS_RouteSecurity.open) {
+        this.haveHttpsServer = true;
         this.httpsServer
           .listen(this._ports.httpsPort, 'localhost', 0, () => {
+            this.httpsServerStarted = true;
             Dynamo_Log.success(`\nHTTPS (secure) server is listening on port ${this._ports.httpsPort}`);
           })
           .on('error', (error) => {
+            this.httpsServerStarted = false;
+            this.constructErrors.push(error);
             Dynamo_Log.error(`\nHTTPS (secure) server ERROR`, error);
           })
           .on('uncaughtException', (ex) => {
@@ -416,11 +532,15 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
 
       if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
-        this.openExpress
+        this.haveHttpServer = true;
+        this.httpServer = this.openExpress
           .listen(this._ports.httpPort, () => {
+            this.httpServerStarted = true;
             Dynamo_Log.success(`\nHTTP (-open-) server is listening on port ${this._ports.httpPort}`);
           })
           .on('error', (error) => {
+            this.httpServerStarted = false;
+            this.constructErrors.push(error);
             Dynamo_Log.error(`\nHTTP (-open-) server ERROR`, error);
           })
           .on('uncaughtException', (ex) => {