@abtnode/router-provider 1.6.21 → 1.6.24

package/lib/nginx/index.js

@@ -10,7 +10,6 @@ const getPort = require('get-port');
 const uniqBy = require('lodash/uniqBy');
 const isEmpty = require('lodash/isEmpty');
 const cloneDeep = require('lodash/cloneDeep');
-const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const {
   DOMAIN_FOR_DEFAULT_SITE,
   ROUTING_RULE_TYPES,
@@ -23,28 +22,31 @@ const md5 = require('@abtnode/util/lib/md5');
 
 const promiseRetry = require('promise-retry');
 
-const logger = require('@abtnode/logger')(`${require('../../package.json').name}:provider:nginx`);
+const logger = require('@abtnode/logger')('router:nginx:controller');
 
 const BaseProvider = require('../base');
-const util = require('./util');
 const {
   addTestServer,
-  decideHttpPort,
-  decideHttpsPort,
   formatError,
   getNginxLoadModuleDirectives,
+  parseNginxConfigArgs,
+  getNginxStatus,
+  rotateNginxLogFile,
+  getMissingModules,
+  getMainTemplate,
+} = require('./util');
+const {
+  decideHttpPort,
+  decideHttpsPort,
   get404Template,
   get502Template,
   get5xxTemplate,
   getWelcomeTemplate,
-  parseNginxConfigArgs,
   trimEndSlash,
   concatPath,
   findCertificate,
-  getNginxStatus,
-  rotateNginxLogFile,
-  getMissingModules,
-} = require('./util');
+  formatRoutingTable,
+} = require('../util');
 
 const REQUIRED_MODULES = [{ configName: 'with-stream', moduleBinaryName: 'ngx_stream_module.so' }];
 
@@ -52,33 +54,33 @@ const REQUIRED_MODULES = [{ configName: 'with-stream', moduleBinaryName: 'ngx_st
 const DID_AUTH_PATH_PREFIX = `${DEFAULT_ADMIN_PATH}/api/did`;
 
 // convert wildcard domain and ipDnsDomain template to regex
-const parseServerName = (serverName) => {
+const parseServerName = (domain) => {
   // ipDnsDomain template
-  if (serverName.includes(SLOT_FOR_IP_DNS_SITE)) {
-    const name = serverName.replace(/\./g, '\\.').replace(SLOT_FOR_IP_DNS_SITE, '\\d+-\\d+-\\d+-\\d+');
+  if (domain.includes(SLOT_FOR_IP_DNS_SITE)) {
+    const name = domain.replace(/\./g, '\\.').replace(SLOT_FOR_IP_DNS_SITE, '\\d+-\\d+-\\d+-\\d+');
     return `~^${name}$`;
   }
 
   // wildcard domain
-  if (serverName.startsWith('*.')) {
-    const name = serverName.replace('*', '').replace(/\./g, '\\.');
+  if (domain.startsWith('*.')) {
+    const name = domain.replace('*', '').replace(/\./g, '\\.');
     return `~.+${name}$`;
   }
 
-  return serverName;
+  return domain;
 };
 
 class NginxProvider extends BaseProvider {
   /**
-   * @param {string} configDirectory
+   * @param {string} configDir
    * @param {number} httpPort
    * @param {number} httpPort
    * @param {number} cacheDisabled
    */
-  constructor({ configDirectory, httpPort, httpsPort, cacheDisabled, isTest }) {
-    super('nginx-provider');
-    if (!configDirectory) {
-      throw new Error('invalid configDirectory');
+  constructor({ configDir, httpPort, httpsPort, cacheDisabled, isTest }) {
+    super('nginx');
+    if (!configDir) {
+      throw new Error('invalid configDir');
     }
 
     if (shelljs.which('nginx')) {
@@ -88,30 +90,30 @@ class NginxProvider extends BaseProvider {
     }
 
     this.isTest = !!isTest;
-    this.configDirectory = configDirectory;
-    this.logDirectory = path.join(this.configDirectory, 'log');
-    this.accessLogFile = path.join(this.logDirectory, 'access.log');
-    this.errorLogFile = path.join(this.logDirectory, 'error.log');
-    this.tmpDirectory = path.join(this.configDirectory, 'tmp');
-    this.certificateDirectory = path.join(this.configDirectory, 'certs');
-    this.includesDirectory = path.join(this.configDirectory, 'includes');
-    this.wwwDirectory = path.join(this.configDirectory, 'www');
+    this.configDir = configDir;
+    this.logDir = path.join(this.configDir, 'log');
+    this.accessLog = path.join(this.logDir, 'access.log');
+    this.errorLog = path.join(this.logDir, 'error.log');
+    this.tmpDir = path.join(this.configDir, 'tmp');
+    this.certDir = path.join(this.configDir, 'certs');
+    this.includesDir = path.join(this.configDir, 'includes');
+    this.wwwDir = path.join(this.configDir, 'www');
 
-    this.configFilePath = path.join(this.configDirectory, 'nginx.conf');
+    this.configPath = path.join(this.configDir, 'nginx.conf');
 
     this.httpPort = decideHttpPort(httpPort);
     this.httpsPort = decideHttpsPort(httpsPort);
     this.cacheDisabled = !!cacheDisabled;
 
     logger.info('nginx provider config', {
-      configDirectory,
+      configDir,
       httpPort: this.httpPort,
       httpsPort: this.httpsPort,
       cacheDisabled: this.cacheDisabled,
     });
 
     // ensure directories
-    [this.configDirectory, this.logDirectory, this.tmpDirectory, this.certificateDirectory].forEach((dir) => {
+    [this.configDir, this.logDir, this.tmpDir, this.certDir].forEach((dir) => {
       if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir);
       }
@@ -123,8 +125,6 @@ class NginxProvider extends BaseProvider {
   }
 
   async update({ routingTable = [], certificates = [], globalHeaders, services = [], nodeInfo = {} } = {}) {
-    logger.info('routing table:', routingTable);
-
     if (!Array.isArray(routingTable)) {
       throw new Error('routingTable must be an array');
     }
@@ -133,9 +133,9 @@ class NginxProvider extends BaseProvider {
 
     // eslint-disable-next-line consistent-return
     return new Promise((resolve, reject) => {
-      const confTemplate = util.getMainTemplate({
-        logDir: this.logDirectory.replace(this.configDirectory, '').replace(/^\//, ''),
-        tmpDirectory: this.tmpDirectory.replace(this.configDirectory, '').replace(/^\//, ''),
+      const confTemplate = getMainTemplate({
+        logDir: this.logDir.replace(this.configDir, '').replace(/^\//, ''),
+        tmpDir: this.tmpDir.replace(this.configDir, '').replace(/^\//, ''),
         workerProcess: this.getWorkerProcess(),
         nginxLoadModules: getNginxLoadModuleDirectives(REQUIRED_MODULES, this.readNginxConfigParams()).join(os.EOL),
       });
@@ -148,90 +148,35 @@ class NginxProvider extends BaseProvider {
         }
 
         conf.on('flushed', () => resolve());
-
-        conf.live(this.configFilePath);
-
-        let addedDefaultServer = false;
-        const rulesMap = new Map();
-        const siteCorsConfigs = [];
-
-        routingTable.forEach((site) => {
-          let serverName = site.domain;
-          if (site.domain === DOMAIN_FOR_DEFAULT_SITE) {
-            serverName = '_';
-            addedDefaultServer = true;
+        conf.live(this.configPath);
+
+        const { sites, configs: siteCorsConfigs } = formatRoutingTable(routingTable, (rules, rule) => {
+          // TODO: this is really hacky, and should be abstracted out
+          if (rule.type === ROUTING_RULE_TYPES.DAEMON && rule.prefix === DEFAULT_ADMIN_PATH) {
+            const clonedRule = cloneDeep(rule);
+            clonedRule.prefix = DID_AUTH_PATH_PREFIX;
+            rules.push(clonedRule);
           }
-
-          siteCorsConfigs.push({ serverName, corsAllowedOrigins: site.corsAllowedOrigins });
-
-          if (!rulesMap.has(serverName)) {
-            rulesMap.set(serverName, {
-              rules: [],
-              port: site.port,
-              corsAllowedOrigins: site.corsAllowedOrigins,
-            });
-          }
-
-          (site.rules || []).forEach((x) => {
-            const prefix = trimEndSlash(x.from.pathPrefix || '/');
-            const groupPrefix = trimEndSlash(x.from.groupPathPrefix || '/');
-            const suffix = trimEndSlash(x.from.pathSuffix || '');
-
-            const rule = {
-              ruleId: x.id,
-              type: x.to.type,
-              prefix,
-              groupPrefix,
-              suffix,
-            };
-            if (x.to.type === ROUTING_RULE_TYPES.REDIRECT) {
-              rule.redirectCode = x.to.redirectCode || 302;
-              rule.url = x.to.url;
-            } else {
-              rule.port = x.to.port;
-              rule.did = x.to.did;
-              rule.realDid = x.to.realDid;
-              rule.target = trimEndSlash(normalizePathPrefix(x.to.target || '/'));
-              rule.services = x.services || [];
-            }
-
-            const tmpPath = concatPath(prefix, suffix);
-            const tmpRules = rulesMap.get(serverName).rules;
-            if (!tmpRules.find(({ prefix: p, suffix: s }) => concatPath(p, s) === tmpPath)) {
-              rulesMap.get(serverName).rules.push(rule);
-
-              if (rule.type === ROUTING_RULE_TYPES.DAEMON && rule.prefix === DEFAULT_ADMIN_PATH) {
-                const clonedRule = cloneDeep(rule);
-                clonedRule.prefix = DID_AUTH_PATH_PREFIX;
-                rulesMap.get(serverName).rules.push(clonedRule);
-              }
-            }
-          });
         });
 
-        logger.debug('rule map:', { rulesMap });
-
         this._addCorsMap(conf, siteCorsConfigs);
-
-        // disable server version
         conf.nginx.http._add('server_tokens', 'off');
         this._addGlobalHeaders(conf, globalHeaders);
-
         this._addExposeServices(conf, services);
 
+        logger.info('routing sites:', sites);
         // eslint-disable-next-line no-restricted-syntax
-        for (const [serverName, { rules: locations, corsAllowedOrigins, port }] of rulesMap) {
-          const certificate = findCertificate(certificates, serverName);
-          const isHttps = !!certificate;
+        for (const site of sites) {
+          const { domain, port, rules, corsAllowedOrigins } = site;
+          const certificate = findCertificate(certificates, domain);
 
-          const parsedServerName = parseServerName(serverName);
-          const sortedLocations = this._sortLocations(locations);
-          if (isHttps) {
+          const parsedServerName = parseServerName(domain);
+          if (certificate) {
             // HTTPS configurations
             // update all certs to disk
             certificates.forEach((item) => {
-              const crtPath = `${path.join(this.certificateDirectory, item.domain)}.crt`;
-              const keyPath = `${path.join(this.certificateDirectory, item.domain)}.key`;
+              const crtPath = `${path.join(this.certDir, item.domain)}.crt`;
+              const keyPath = `${path.join(this.certDir, item.domain)}.key`;
               fs.writeFileSync(crtPath, item.certificate);
               fs.writeFileSync(keyPath, item.privateKey);
             });
@@ -239,7 +184,7 @@ class NginxProvider extends BaseProvider {
             // if match certificate, then add https server
             this._addHttpsServer({
               conf,
-              locations: sortedLocations,
+              locations: rules,
               certificateFileName: certificate.domain,
               serverName: parsedServerName,
               corsAllowedOrigins,
@@ -248,7 +193,7 @@ class NginxProvider extends BaseProvider {
           } else {
             this._addHttpServer({
               conf,
-              locations: sortedLocations,
+              locations: rules,
               serverName: parsedServerName,
               corsAllowedOrigins,
               port,
@@ -257,7 +202,7 @@ class NginxProvider extends BaseProvider {
           }
         }
 
-        if (addedDefaultServer === false) {
+        if (!sites.find((x) => x.domain === '_')) {
           this._addDefaultServer(conf, nodeInfo.port);
         }
 
@@ -267,8 +212,8 @@ class NginxProvider extends BaseProvider {
   }
 
   async reload() {
-    const nginxStatus = await getNginxStatus(this.configFilePath);
-    if (nginxStatus.ownByABTNode) {
+    const nginxStatus = await getNginxStatus(this.configPath);
+    if (nginxStatus.managed) {
       const result = this._exec('reload');
       logger.info('reload:reload', { result: result.stdout });
       return result;
@@ -296,12 +241,12 @@ class NginxProvider extends BaseProvider {
 
   // FIXME: 这个函数可以不暴露出去？
   initialize() {
-    if (!fs.existsSync(this.configFilePath)) {
+    if (!fs.existsSync(this.configPath)) {
       fs.writeFileSync(
-        this.configFilePath,
-        util.getMainTemplate({
-          logDir: this.logDirectory.replace(this.configDirectory, '').replace(/^\//, ''),
-          tmpDirectory: this.tmpDirectory.replace(this.configDirectory, '').replace(/^\//, ''),
+        this.configPath,
+        getMainTemplate({
+          logDir: this.logDir.replace(this.configDir, '').replace(/^\//, ''),
+          tmpDir: this.tmpDir.replace(this.configDir, '').replace(/^\//, ''),
           nginxLoadModules: getNginxLoadModuleDirectives(REQUIRED_MODULES, this.readNginxConfigParams()).join(os.EOL),
           workerProcess: this.getWorkerProcess(),
         })
@@ -310,7 +255,7 @@ class NginxProvider extends BaseProvider {
   }
 
   async validateConfig() {
-    const command = `${this.binPath} -t -c ${this.configFilePath} -p ${this.configDirectory}`; // eslint-disable-line no-param-reassign
+    const command = `${this.binPath} -t -c ${this.configPath} -p ${this.configDir}`; // eslint-disable-line no-param-reassign
     const result = shelljs.exec(command, { silent: true });
     if (result.code !== 0) {
       logger.info(`exec ${command} error`, { error: result.stderr });
@@ -319,41 +264,29 @@ class NginxProvider extends BaseProvider {
   }
 
   async rotateLogs() {
-    const nginxStatus = await getNginxStatus(this.configDirectory);
-    if (!nginxStatus.ownByABTNode) {
+    const nginxStatus = await getNginxStatus(this.configDir);
+    if (!nginxStatus.managed) {
       logger.warn('nginx is not running');
       return;
     }
 
     logger.info('start rotate nginx log files');
-    const files = [this.accessLogFile, this.errorLogFile];
+    const files = [this.accessLog, this.errorLog];
     const rotateTasks = files.map(
-      (file) => rotateNginxLogFile({ file, nginxPid: nginxStatus.pid, cwd: this.logDirectory })
+      (file) => rotateNginxLogFile({ file, nginxPid: nginxStatus.pid, cwd: this.logDir })
       // eslint-disable-next-line function-paren-newline
     );
     await Promise.all(rotateTasks);
     logger.info('rotate nginx log files finished');
   }
 
-  getWorkerProcess() {
-    if (this.isTest) {
-      return 1;
-    }
-
-    if (process.env.NODE_ENV === 'production') {
-      return os.cpus().length;
-    }
-
-    return 1;
-  }
-
   /**
    * execute nginx command, default is to start nginx
    * @param {string} param param of nginx -s {param}
    */
   _exec(param = '') {
     logger.info('exec', { param });
-    let command = `${this.binPath}  -c ${this.configFilePath} -p ${this.configDirectory}`; // eslint-disable-line no-param-reassign
+    let command = `${this.binPath}  -c ${this.configPath} -p ${this.configDir}`; // eslint-disable-line no-param-reassign
     if (param) {
       command = `${command} -s ${param}`;
     }
@@ -396,6 +329,11 @@ class NginxProvider extends BaseProvider {
       return;
     }
 
+    if (type === ROUTING_RULE_TYPES.DIRECT_RESPONSE) {
+      this._addDirectResponseLocation(args);
+      return;
+    }
+
     if (type === ROUTING_RULE_TYPES.NONE) {
       this._addNotFoundLocation(args);
       return;
@@ -509,7 +447,7 @@ class NginxProvider extends BaseProvider {
   }
 
   _addRedirectTypeLocation({ server, url, redirectCode, prefix, suffix }) {
-    const formatedUrl = trimEndSlash(url);
+    const cleanUrl = trimEndSlash(url);
 
     server._add('location', `${concatPath(prefix, suffix)}`);
     const location = this._getLastLocation(server);
@@ -517,15 +455,15 @@ class NginxProvider extends BaseProvider {
     location._addVerbatimBlock('if ($query_string)', 'set $abt_query_string "?$query_string";');
 
     // 如果当前请求的 path 和 prefix 一样，则不需要重写，直接返回重定向地址就可以了
-    location._addVerbatimBlock(`if ($uri = ${prefix})`, `return ${redirectCode} ${formatedUrl}$abt_query_string;`);
+    location._addVerbatimBlock(`if ($uri = ${prefix})`, `return ${redirectCode} ${cleanUrl}$abt_query_string;`);
 
     // 如果 prefix 是根路径，则不需要重写，直接将当前的请求附加到设置的重定向地址后面
     if (prefix === '/') {
-      location._add('return', `${redirectCode} ${formatedUrl}$request_uri`);
+      location._add('return', `${redirectCode} ${cleanUrl}$request_uri`);
     } else {
       // 将当前请求中的 prefix 去掉，然后拼接对应的重定地址
       location._add('rewrite', `^${prefix}(.*) $1`);
-      location._add('return', `${redirectCode} ${formatedUrl === '/' ? '' : formatedUrl}$1$abt_query_string`);
+      location._add('return', `${redirectCode} ${cleanUrl === '/' ? '' : cleanUrl}$1$abt_query_string`);
     }
   }
 
@@ -545,6 +483,17 @@ class NginxProvider extends BaseProvider {
     location._add('proxy_pass', `http://127.0.0.1:${port}`);
   }
 
+  _addDirectResponseLocation({ server, response, prefix, suffix }) {
+    server._add('location', concatPath(prefix, suffix));
+    const location = this._getLastLocation(server);
+    this._addCommonHeader(location);
+    if (response.contentType) {
+      location._add('default_type', response.contentType);
+    }
+
+    location._add('return', `${response.status} "${response.body}"`);
+  }
+
   /**
    * The main purpose is to add a slash(/) suffix to the address.
    * @param {object} location nginx-conf location object
@@ -591,7 +540,7 @@ class NginxProvider extends BaseProvider {
       throw new Error('daemonPort is required');
     }
 
-    server._add('root', this.wwwDirectory.replace(this.configDirectory, '').replace(/^\//, ''));
+    server._add('root', this.wwwDir.replace(this.configDir, '').replace(/^\//, ''));
     server._add('error_page', '404 =404 /_abtnode_404');
     server._add('error_page', '502 =502 /_abtnode_502');
     server._add('error_page', '500 502 503 504 =500 /_abtnode_5xx');
@@ -616,21 +565,21 @@ class NginxProvider extends BaseProvider {
 
   _addWwwFiles(nodeInfo) {
     const welcomePage = nodeInfo.enableWelcomePage ? getWelcomeTemplate(nodeInfo) : get404Template(nodeInfo);
-    fs.writeFileSync(`${this.wwwDirectory}/index.html`, welcomePage); // disable index.html
-    fs.writeFileSync(`${this.wwwDirectory}/404.html`, get404Template(nodeInfo));
-    fs.writeFileSync(`${this.wwwDirectory}/502.html`, get502Template(nodeInfo));
-    fs.writeFileSync(`${this.wwwDirectory}/5xx.html`, get5xxTemplate(nodeInfo));
+    fs.writeFileSync(`${this.wwwDir}/index.html`, welcomePage); // disable index.html
+    fs.writeFileSync(`${this.wwwDir}/404.html`, get404Template(nodeInfo));
+    fs.writeFileSync(`${this.wwwDir}/502.html`, get502Template(nodeInfo));
+    fs.writeFileSync(`${this.wwwDir}/5xx.html`, get5xxTemplate(nodeInfo));
   }
 
   _copyConfigFiles() {
-    fs.copySync(path.join(__dirname, 'includes'), this.includesDirectory, {
+    fs.copySync(path.join(__dirname, 'includes'), this.includesDir, {
       overwrite: true,
     });
-    fs.copySync(path.join(__dirname, '..', 'www'), this.wwwDirectory, { overwrite: true });
+    fs.copySync(path.join(__dirname, '..', 'www'), this.wwwDir, { overwrite: true });
   }
 
   _ensureDhparam() {
-    const targetFile = path.join(this.includesDirectory, 'dhparam.pem');
+    const targetFile = path.join(this.includesDir, 'dhparam.pem');
     if (fs.existsSync(targetFile)) {
       this._isDhparamGenerated = true;
       return;
@@ -658,19 +607,6 @@ class NginxProvider extends BaseProvider {
     }
   }
 
-  _sortLocations(rules = []) {
-    const rulesWithoutSuffix = rules.filter((x) => !x.suffix);
-    const rulesWithSuffix = rules
-      .filter((x) => x.suffix)
-      .sort((a, b) => {
-        const lenA = (a.prefix || '').length + (a.prefix || '').length;
-        const lenB = (b.prefix || '').length + (b.prefix || '').length;
-        return lenB - lenA;
-      });
-
-    return rulesWithoutSuffix.concat(rulesWithSuffix);
-  }
-
   _addGlobalHeaders(conf, headers) {
     if (!headers || Object.prototype.toString.call(headers) !== '[object Object]') {
       return;
@@ -746,8 +682,8 @@ class NginxProvider extends BaseProvider {
     conf.nginx.http._add('server');
     const httpsServerUnit = this._getLastServer(conf);
 
-    const crtPath = `${path.join(this.certificateDirectory, certificateFileName)}.crt`;
-    const keyPath = `${path.join(this.certificateDirectory, certificateFileName)}.key`;
+    const crtPath = `${path.join(this.certDir, certificateFileName)}.crt`;
+    const keyPath = `${path.join(this.certDir, certificateFileName)}.key`;
 
     let listen = `${this.httpsPort} ssl`;
     if (serverName === '_') {
@@ -804,12 +740,19 @@ class NginxProvider extends BaseProvider {
 
         allowedOrigins.push('default "";');
         conf.nginx.http._addVerbatimBlock(
-          `map $http_origin $allow_origin_${md5(parseServerName(corsConfig.serverName))}`,
+          `map $http_origin $allow_origin_${md5(parseServerName(corsConfig.domain))}`,
           allowedOrigins.join(' ')
         );
       }
     });
   }
+
+  getLogFilesForToday() {
+    return {
+      access: this.accessLog,
+      error: this.errorLog,
+    };
+  }
 }
 
 NginxProvider.describe = async ({ configDir = '' } = {}) => {
@@ -846,20 +789,21 @@ NginxProvider.check = async ({ configDir = '' } = {}) => {
 
   if (!binPath) {
     result.available = false;
-    result.error = 'nginx is not detected, make sure you have nginx installed.';
+    result.error =
+      'Nginx is not detected, to have nginx installed you can checkout: https://nginx.org/en/docs/install.html.';
     return result;
   }
 
   const nginxStatus = await getNginxStatus(configDir);
-  if (nginxStatus.running && !nginxStatus.ownByABTNode) {
+  if (nginxStatus.running && !nginxStatus.managed) {
     result.available = false;
     result.error =
-      'seems a nginx daemon is already running on your machine, a controlled nginx is required by Blocklet Server to work properly, please terminate the running nginx daemon before try again.';
+      'Seems a nginx daemon already running, a controlled nginx is required by Blocklet Server to work properly, please terminate the running nginx daemon before try again.';
 
     return result;
   }
 
-  if (nginxStatus.ownByABTNode) {
+  if (nginxStatus.managed) {
     const pidFile = path.join(configDir, 'nginx/nginx.pid');
     if (fs.existsSync(pidFile)) {
       const diskPid = Number(fs.readFileSync(pidFile).toString().trim());
@@ -882,12 +826,12 @@ NginxProvider.check = async ({ configDir = '' } = {}) => {
   );
   fs.mkdirSync(tempConfigDirectory, { recursive: true });
 
-  const nginxProvider = new NginxProvider({ configDirectory: tempConfigDirectory, isTest: true });
+  const nginxProvider = new NginxProvider({ configDir: tempConfigDirectory, isTest: true });
   nginxProvider.initialize();
 
-  logger.info('check:addTestServer', { configFilePath: nginxProvider.configFilePath });
+  logger.info('check:addTestServer', { configPath: nginxProvider.configPath });
   await addTestServer({
-    configFilePath: nginxProvider.configFilePath,
+    configPath: nginxProvider.configPath,
     port: await getPort(),
     upstreamPort: await getPort(),
   });
@@ -911,13 +855,5 @@ NginxProvider.check = async ({ configDir = '' } = {}) => {
 
 NginxProvider.getStatus = getNginxStatus;
 NginxProvider.exists = () => !!shelljs.which('nginx');
-NginxProvider.getLogFilesOfCurrentDay = (routerDirectory) => {
-  const logDirectory = path.join(routerDirectory, 'log');
-
-  return {
-    access: path.join(logDirectory, 'access.log'),
-    error: path.join(logDirectory, 'error.log'),
-  };
-};
 
 module.exports = NginxProvider;