2.0.13

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: hosttoday/ht-docker-node:npmts
+image: hosttoday/ht-docker-node:npmci
 
 stages:
 - test
@@ -10,16 +10,19 @@ before_script:
 testSTABLE:
   stage: test
   script:
+    - npmci npm install
     - npmci npm test stable
   only:
     - tags
   tags:
     - docker
+    - notpriv
 
 release:
   stage: release
   environment: npmjs-com_registry
   script:
+    - npmci npm prepare
     - npmci npm publish
   only:
     - tags

npmextra.json

@@ -0,0 +1,8 @@
+{
+  "npmci": {
+    "npmAccessLevel": "public"
+  },
+  "npmdocker": {
+    
+  }
+}

package.json

@@ -1,6 +1,7 @@
 {
   "name": "@pushrocks/smartnginx",
-  "version": "2.0.0",
+  "version": "2.0.13",
+  "private": false,
   "description": "control nginx from node, TypeScript ready",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -23,18 +24,20 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartnginx#README",
   "dependencies": {
-    "@pushrocks/smartfile": "^6.0.6",
+    "@pushrocks/lik": "^3.0.4",
-    "@pushrocks/smartlog": "^2.0.1",
+    "@pushrocks/smartfile": "^6.0.11",
+    "@pushrocks/smartlog": "^2.0.9",
     "@pushrocks/smartpromise": "^2.0.5",
-    "@pushrocks/smartshell": "^2.0.6",
+    "@pushrocks/smartshell": "^2.0.13",
-    "@pushrocks/smartstring": "^3.0.0"
+    "@pushrocks/smartstring": "^3.0.5"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.0.22",
+    "@gitzone/tsbuild": "^2.1.4",
-    "@gitzone/tsrun": "^1.1.12",
+    "@gitzone/tsrun": "^1.1.17",
-    "@gitzone/tstest": "^1.0.13",
+    "@gitzone/tstest": "^1.0.18",
-    "@pushrocks/tapbundle": "^3.0.5",
+    "@pushrocks/qenv": "^3.0.2",
-    "qenv": "^1.1.7"
+    "@pushrocks/tapbundle": "^3.0.7",
-  },
+    "tslint": "^5.12.0",
-  "private": true
+    "tslint-config-prettier": "^1.17.0"
+  }
 }

test/test.ts

@@ -1,32 +1,34 @@
 import { tap, expect } from '@pushrocks/tapbundle';
 import path = require('path');
 
-import { Qenv } from 'qenv';
+import { Qenv } from '@pushrocks/qenv';
-let testQenv = new Qenv(process.cwd(), path.join(process.cwd(), '.nogit'));
+const testQenv = new Qenv('./', './.nogit/');
 
-
+import * as smartnginx from '../ts/index';
-import * as smartnginx from '../ts';
 
 let testSmartNginx: smartnginx.SmartNginx;
 let testNginxZone01: smartnginx.NginxHost;
 let testNginxZone02: smartnginx.NginxHost;
 
 tap.test('should create a valid instance of SmartNginx', async () => {
-  testSmartNginx = new smartnginx.SmartNginx();
+  testSmartNginx = new smartnginx.SmartNginx({});
   expect(testSmartNginx).to.be.instanceof(smartnginx.SmartNginx);
 });
 
 tap.test(`should produce an instance of NginxConfig`, async () => {
   testNginxZone01 = new smartnginx.NginxHost(testSmartNginx, {
     hostName: 'test100.bleu.de',
-    destination: '192.192.192.191'
+    destination: '192.192.192.191',
+    privateKey: 'some private',
+    publicKey: 'some public'
   });
   testNginxZone02 = new smartnginx.NginxHost(testSmartNginx, {
     hostName: 'test102.bleu.de',
-    destination: '192.192.192.192'
+    destination: '192.192.192.192',
+    privateKey: 'some private',
+    publicKey: 'some public'
   });
   expect(testNginxZone01).to.be.instanceof(smartnginx.NginxHost);
-  console.log(testNginxZone01.configString);
 });
 
 tap.test('.addZone() should add a zone to NginxConfig Object', async () => {

ts/interfaces/hostconfig.ts

@@ -0,0 +1,6 @@
+export interface IHostConfig {
+  hostName: string;
+  destination: string;
+  privateKey: string;
+  publicKey: string;
+}

ts/smartnginx.classes.certhandler.ts

@@ -1,5 +0,0 @@
-import * as plugins from './smartnginx.plugins';
-
-export class CertHandler {
-
-}

ts/smartnginx.classes.nginxhost.ts

@@ -4,13 +4,7 @@ import * as snippets from './smartnginx.snippets';
 
 import { SmartNginx } from './smartnginx.classes.smartnginx';
 
-/**
+import { IHostConfig } from './interfaces/hostconfig';
- * the host config data that NginxHost needs to create a valid instance
- */
-export interface IHostConfigData {
-  hostName: string;
-  destination: string;
-}
 
 export enum hostTypes {
   reverseProxy
@@ -19,29 +13,41 @@ export enum hostTypes {
 /**
  * manages a single nginx host
  */
-export class NginxHost {
+export class NginxHost implements IHostConfig {
   /**
    * smartnginxInstance this NginHost belongs to
    */
-  smartnginxInstance: SmartNginx
+  smartnginxInstance: SmartNginx;
 
   hostName: string; // the host name e.g. domain name
   destination: string;
   configString: string; // the actual host config file as string
-  constructor(smartnginxInstanceArg: SmartNginx, optionsArg: IHostConfigData) {
+  privateKey: string;
+  publicKey: string;
+
+  constructor(smartnginxInstanceArg: SmartNginx, optionsArg: IHostConfig) {
     this.smartnginxInstance = smartnginxInstanceArg;
     this.hostName = optionsArg.hostName;
     this.destination = optionsArg.destination;
     this.configString = snippets.getHostConfigString(optionsArg.hostName, optionsArg.destination);
+    this.privateKey = optionsArg.privateKey;
+    this.publicKey = optionsArg.publicKey;
   }
 
   /**
    *
    * @param certInstanceArg
    */
-  async deploy() {
+  public async deploy() {
-    let filePath = plugins.path.join(paths.nginxHostFileBase, this.hostName + '.conf');
+    const filePathConfig = plugins.path.join(paths.nginxHostDirPath,  `${this.hostName}.conf`);
+    const filePathPrivate = plugins.path.join(paths.nginxHostDirPath,  `${this.hostName}.private.pem`);
+    const filePathPublic = plugins.path.join(paths.nginxHostDirPath,  `${this.hostName}.public.pem`);
     // writeConfig
-    plugins.smartfile.memory.toFsSync(this.configString, filePath);
+    plugins.smartfile.memory.toFsSync(this.configString, filePathConfig);
+
+    // write ssl
+    plugins.smartfile.memory.toFsSync(this.privateKey, filePathPrivate);
+    plugins.smartfile.memory.toFsSync(this.publicKey, filePathPublic);
+
   }
 }

ts/smartnginx.classes.nginxprocess.ts

@@ -5,78 +5,65 @@ import { NginxHost } from './smartnginx.classes.nginxhost';
 
 import { Smartshell } from '@pushrocks/smartshell';
 
+import { ChildProcess } from 'child_process';
+
 /**
  * manages a nginxprocess for an NginxConfig
  */
 export class NginxProcess {
-  started: boolean = false;
+  public started: boolean = false;
-  nginxConfig: SmartNginx;
+  public smartNginxRef: SmartNginx;
-  nginxChildProcess: plugins.childProcess.ChildProcess;
+  private nginxChildProcess: ChildProcess;
-  smartshellInstance = new Smartshell({
+  private smartshellInstance = new Smartshell({
     executor: 'bash'
   });
-  constructor(nginxConfigArg) {
+
-    this.nginxConfig = nginxConfigArg;
+  constructor(nginxRefArg: SmartNginx) {
+    this.smartNginxRef = nginxRefArg;
   }
 
   /**
    * start nginx
    */
-  start() {
+  public async start() {
-    let done = plugins.smartpromise.defer();
+    if (!this.nginxChildProcess) {
-    if (typeof this.nginxChildProcess == 'undefined') {
+      this.nginxChildProcess = (await this.smartshellInstance.execStreaming(
-      this.nginxChildProcess = plugins.childProcess.exec(
+        `nginx -c ${paths.nginxConfFile}`
-        `nginx -c ${paths.nginxConfFile}`,
+      )).childProcess;
-        function(error, stdout, stderr) {
-          console.log(`stdout: ${stdout}`);
-          console.log(`stderr: ${stderr}`);
-          if (error !== null) {
-            console.log(`exec error: ${error}`);
-          }
-        }
-      );
     }
     this.started = true;
-    plugins.smartlog.defaultLogger.info('started Nginx!');
+    plugins.smartlog.defaultLogger.log('info', 'started Nginx!');
-    done.resolve();
-    return done.promise;
   }
 
   /**
    * reload config
    */
-  reloadConfig() {
+  public async reloadConfig() {
-    let done = plugins.smartpromise.defer();
+    if (!this.started) {
-    if (this.started == false) {
       this.start();
     } else {
-      this.smartshellInstance.exec('nginx -s reload');
+      await this.smartshellInstance.exec('nginx -s reload');
     }
-    plugins.smartlog.defaultLogger.info('NginxProcess has loaded the new config!');
+    this.smartNginxRef.logger.log('info', 'NginxProcess has loaded the new config!');
-    done.resolve();
-    return done.promise;
   }
 
   /**
    * stop the nginx instance
    */
-  stop() {
+  public async stop() {
-    let done = plugins.smartpromise.defer();
+    if (this.nginxChildProcess) {
-    if (typeof this.nginxChildProcess != 'undefined') {
       this.smartshellInstance.exec('nginx -s quit');
       this.started = false;
-      plugins.smartlog.defaultLogger.info('stopped Nginx!');
+      this.smartNginxRef.logger.log('info', 'stopped Nginx!');
     } else {
-      plugins.smartlog.defaultLogger.info('nginx already stopped!');
+      this.smartNginxRef.logger.log('info', 'nginx already stopped!');
     }
-    done.resolve();
-    return done.promise;
   }
 
   /**
    * checks if nginx is in path
    */
-  check(): boolean {
+  public check(): boolean {
     return;
   }
 }

ts/smartnginx.classes.smartnginx.ts

@@ -3,20 +3,20 @@ import * as paths from './smartnginx.paths';
 import * as snippets from './smartnginx.snippets';
 import { NginxHost } from './smartnginx.classes.nginxhost';
 import { NginxProcess } from './smartnginx.classes.nginxprocess';
-import { CertHandler } from './smartnginx.classes.certhandler';
+import { IHostConfig } from './interfaces/hostconfig';
-let allConfigs: SmartNginx[] = [];
 
 /**
  * main class that manages a NginxInstance
  */
 export class SmartNginx {
-  certHandler = new CertHandler();
+  public logger: plugins.smartlog.Smartlog;
-  hosts: NginxHost[] = [];
+  private hosts = new plugins.lik.Objectmap<NginxHost>();
-  nginxProcess: NginxProcess = new NginxProcess(this);
+  public nginxProcess: NginxProcess = new NginxProcess(this);
-  isDeployed: boolean = false;
+  constructor(optionsArg: { logger?: plugins.smartlog.Smartlog }) {
-  constructor() {
+    optionsArg.logger
-
+      ? (this.logger = optionsArg.logger)
-  };
+      : (this.logger = plugins.smartlog.defaultLogger);
+  }
 
   // ===================
   // interact with Hosts
@@ -26,49 +26,57 @@ export class SmartNginx {
    * add a host
    * @param nginxHostArg
    */
-  addHost(nginxHostArg: NginxHost) {
+  public addHost(optionsArg: IHostConfig): NginxHost {
-    this.hosts.push(nginxHostArg);
+    const nginxHost = new NginxHost(this, optionsArg);
+    this.hosts.add(nginxHost);
+    return nginxHost;
   }
 
+  /**
+   * Gets a NginxHost by hostname
+   * @param hostNameArg
+   */
+  public getNginxHostByHostName(hostNameArg: string): NginxHost {
+    return this.hosts.find(nginxHost => {
+      return nginxHost.hostName === hostNameArg;
+    });
+  }
   /**
    * listHosts
    */
-  listHosts(): NginxHost[] {
+  public listHosts(): NginxHost[] {
-    return this.hosts;
+    return this.hosts.getArray();
   }
 
   /**
    * remove a Host
    * @param nginxHostArg
    */
-  removeHost(nginxHostArg: NginxHost) {}
+  public removeHost(nginxHostArg: NginxHost) {
+    this.hosts.remove(nginxHostArg);
+  }
 
   /**
    * clean all hosts
    */
-  clean() {
+  public wipeHosts() {
-    this.hosts = [];
+    this.hosts.wipe();
   }
 
   /**
    * deploy the current stack and restart nginx
    */
-  async deploy() {
+  public async deploy() {
-    plugins.smartfile.fs.ensureDirSync(paths.nginxConfigBase);
-    plugins.smartfile.fs.ensureDirSync(paths.nginxHostFileBase);
-    plugins.smartfile.fs.ensureDirSync(paths.nginxCertBase);
-    for (let config of allConfigs) {
-      config.isDeployed = false;
-    }
-    this.isDeployed = true;
     // write base config
+    plugins.smartfile.fs.ensureDirSync(paths.nginxConfigDirPath);
     plugins.smartfile.memory.toFsSync(snippets.getBaseConfigString(), paths.nginxConfFile);
+
     // deploy hosts
-    let promiseArray = [];
+    plugins.smartfile.fs.ensureEmptyDirSync(paths.nginxHostDirPath);
-    for (let host of this.hosts) {
+    for (const host of this.hosts.getArray()) {
       await host.deploy();
-      plugins.smartlog.defaultLogger.info(`Host ${host.hostName} deployed!`);
+      this.logger.log('info', `Host ${host.hostName} deployed!`);
+    }
     this.nginxProcess.reloadConfig();
-    };
   }
 }

ts/smartnginx.paths.ts

@@ -1,11 +1,9 @@
 import * as plugins from './smartnginx.plugins';
 
 // directories
-export let packageBase = plugins.path.join(__dirname, '../');
+export const packageBase = plugins.path.join(__dirname, '../');
-export let nginxConfigBase = plugins.path.join(packageBase, 'nginxconfig');
+export const nginxConfigDirPath = plugins.path.join(packageBase, 'nginxconfig');
-
+export const nginxHostDirPath = plugins.path.join(nginxConfigDirPath, 'hosts');
-export let nginxHostFileBase = plugins.path.join(nginxConfigBase, 'hosts');
-export let nginxCertBase = plugins.path.join(nginxConfigBase, 'cert');
 
 // files
-export let nginxConfFile = plugins.path.join(nginxConfigBase, 'nginx.conf');
+export const nginxConfFile = plugins.path.join(nginxConfigDirPath, 'nginx.conf');

ts/smartnginx.plugins.ts

@@ -1,17 +1,14 @@
-import * as smartlog from '@pushrocks/smartlog';
+// native
-import * as childProcess from 'child_process';
 import * as path from 'path';
+
+export { path };
+
+// @pushrocks scope
+import * as lik from '@pushrocks/lik';
+import * as smartlog from '@pushrocks/smartlog';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as smartshell from '@pushrocks/smartshell';
 import * as smartfile from '@pushrocks/smartfile';
 import * as smartstring from '@pushrocks/smartstring';
 
-export {
+export { lik, smartlog, smartpromise, smartshell, smartfile, smartstring };
-  smartlog,
-  childProcess,
-  path,
-  smartpromise,
-  smartshell,
-  smartfile,
-  smartstring
-}

ts/smartnginx.snippets.ts

@@ -63,7 +63,7 @@ export let getBaseConfigString = () => {
 			# Virtual Host Configs
 			##
 
-			include ${paths.nginxHostFileBase}/*.conf;
+			include ${paths.nginxHostDirPath}/*.conf;
 			include /etc/nginx/sites-enabled/*;
 		}
 		daemon off;
@@ -86,12 +86,15 @@ export let getHostConfigString = (hostNameArg: string, destinationIpArg: string)
 		server {
 			listen *:443 ssl;
 			server_name ${hostNameArg};
-			ssl_certificate ${paths.nginxCertBase}/${hostNameArg}/fullchain.pem;
+			ssl_certificate ${paths.nginxHostDirPath}/${hostNameArg}.public.pem;
-			ssl_certificate_key ${paths.nginxCertBase}/${hostNameArg}/privkey.pem;
+			ssl_certificate_key ${paths.nginxHostDirPath}/${hostNameArg}.private.pem;
 
 			location / {
+				proxy_set_header Host $http_host;
+				proxy_set_header X-Real-IP $remote_addr;
+				proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+				proxy_set_header X-Forwarded-Proto $scheme;
 				proxy_pass http://${hostNameArg};
-				include /etc/nginx/proxy_params;
 			}
 			location ~ /\.git {
 				deny all;

tslint.json

@@ -0,0 +1,17 @@
+{
+  "extends": ["tslint:latest", "tslint-config-prettier"],
+  "rules": {
+    "semicolon": [true, "always"],
+    "no-console": false,
+    "ordered-imports": false,
+    "object-literal-sort-keys": false,
+    "member-ordering": {
+      "options":{
+        "order": [
+          "static-method"
+        ]
+      }
+    }
+  },
+  "defaultSeverity": "warning"
+}