fix(core): update

ts/smartnginx.classes.nginxhost.ts

@@ -17,13 +17,13 @@ export class NginxHost implements IHostConfig {
   /**
    * smartnginxInstance this NginHost belongs to
    */
-  smartnginxInstance: SmartNginx;
+  public smartnginxInstance: SmartNginx;
 
-  hostName: string; // the host name e.g. domain name
-  destination: string;
-  configString: string; // the actual host config file as string
-  privateKey: string;
-  publicKey: string;
+  public hostName: string; // the host name e.g. domain name
+  public destination: string;
+  public configString: string; // the actual host config file as string
+  public privateKey: string;
+  public publicKey: string;
 
   constructor(smartnginxInstanceArg: SmartNginx, optionsArg: IHostConfig) {
     this.smartnginxInstance = smartnginxInstanceArg;

ts/smartnginx.classes.smartnginx.ts

@@ -10,7 +10,11 @@ import { IHostConfig } from './interfaces/hostconfig';
  */
 export class SmartNginx {
   public logger: plugins.smartlog.Smartlog;
-  private hosts = new plugins.lik.Objectmap<NginxHost>();
+
+  // the objectmaps
+  private deployedHosts = new plugins.lik.Objectmap<NginxHost>();
+  private hostCandidates = new plugins.lik.Objectmap<NginxHost>();
+
   public nginxProcess: NginxProcess = new NginxProcess(this);
   constructor(optionsArg: { logger?: plugins.smartlog.Smartlog }) {
     optionsArg.logger
@@ -26,9 +30,9 @@ export class SmartNginx {
    * add a host
    * @param nginxHostArg
    */
-  public addHost(optionsArg: IHostConfig): NginxHost {
+  public addHostCandidate(optionsArg: IHostConfig): NginxHost {
     const nginxHost = new NginxHost(this, optionsArg);
-    this.hosts.add(nginxHost);
+    this.hostCandidates.add(nginxHost);
     return nginxHost;
   }
 
@@ -36,47 +40,84 @@ export class SmartNginx {
    * Gets a NginxHost by hostname
    * @param hostNameArg
    */
-  public getNginxHostByHostName(hostNameArg: string): NginxHost {
-    return this.hosts.find(nginxHost => {
+  public getDeployedNginxHostByHostName(hostNameArg: string): NginxHost {
+    return this.deployedHosts.find(nginxHost => {
       return nginxHost.hostName === hostNameArg;
     });
   }
   /**
    * listHosts
    */
-  public listHosts(): NginxHost[] {
-    return this.hosts.getArray();
+  public async listDeployedHosts(): Promise<NginxHost[]> {
+    return this.deployedHosts.getArray();
   }
 
   /**
    * remove a Host
    * @param nginxHostArg
    */
-  public removeHost(nginxHostArg: NginxHost) {
-    this.hosts.remove(nginxHostArg);
+  public async removeDeployedHost(nginxHostArg: NginxHost) {
+    if (this.hostCandidates.isEmpty()) {
+      this.deployedHosts.forEach(hostArg => {
+        this.hostCandidates.add(hostArg);
+      });
+    }
+    this.hostCandidates.remove(nginxHostArg);
+    this.deploy();
   }
 
   /**
-   * clean all hosts
+   * check wether there has been a diverging host configuration
+   * this function will only redeploy the nginx configuration in case there has been a change
    */
-  public wipeHosts() {
-    this.hosts.wipe();
+  private areHostsDiverged(): boolean {
+    let hostCounter = 0;
+    let unfoundHosts = 0;
+    this.hostCandidates.forEach(hostCandidateArg => {
+      let foundHost = false;
+      this.deployedHosts.forEach(deployedHostArg => {
+        if (
+          hostCandidateArg.hostName === deployedHostArg.hostName &&
+          hostCandidateArg.destination === deployedHostArg.destination
+        ) {
+          hostCounter++;
+          foundHost = true;
+        }
+      });
+      if (!foundHost) {
+        unfoundHosts++;
+      }
+    });
+    return (
+      this.deployedHosts.getArray.length !== this.hostCandidates.getArray().length ||
+      hostCounter !== this.deployedHosts.getArray().length ||
+      unfoundHosts !== 0
+    );
   }
 
   /**
    * deploy the current stack and restart nginx
    */
   public async deploy() {
-    // write base config
-    plugins.smartfile.fs.ensureDirSync(paths.nginxConfigDirPath);
-    plugins.smartfile.memory.toFsSync(snippets.getBaseConfigString(), paths.nginxConfFile);
+    if (this.areHostsDiverged()) {
+      this.logger.log('ok', `hosts have diverged, trigger config deployment and nginx reload!`);
+      this.deployedHosts.wipe();
+      this.deployedHosts.addArray(this.hostCandidates.getArray());
+      this.hostCandidates.wipe();
 
-    // deploy hosts
-    plugins.smartfile.fs.ensureEmptyDirSync(paths.nginxHostDirPath);
-    for (const host of this.hosts.getArray()) {
-      await host.deploy();
-      this.logger.log('info', `Host ${host.hostName} deployed!`);
+      // write base config
+      plugins.smartfile.fs.ensureDirSync(paths.nginxConfigDirPath);
+      plugins.smartfile.memory.toFsSync(snippets.getBaseConfigString(), paths.nginxConfFile);
+
+      // deploy hosts
+      plugins.smartfile.fs.ensureEmptyDirSync(paths.nginxHostDirPath);
+      for (const host of this.deployedHosts.getArray()) {
+        await host.deploy();
+        this.logger.log('info', `Host ${host.hostName} deployed!`);
+      }
+      this.nginxProcess.reloadConfig();
+    } else {
+      this.logger.log('info', `hosts have not diverged, skipping nginx reload`);
     }
-    this.nginxProcess.reloadConfig();
   }
 }