mrfrys-node-server/server.js

/* ----------------------------------------------------------------------------

 Question Server
 GitLab: <https://gitlab.com/MrFry/question-node-server>

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.

 ------------------------------------------------------------------------- */

const startHTTPS = true
const port = 8080
const httpsport = 8443

const express = require('express')
const vhost = require('vhost')
const logger = require('./utils/logger.js')
const utils = require('./utils/utils.js')
const fs = require('fs')
const http = require('http')
const https = require('https')
const stat = require('./utils/stat.js')
stat.Load()

const loggableKeywords = [
  'user.js'
]
let modules = {
  qmining: {
    path: './modules/qmining.js',
    name: 'qmining',
    urls: [ 'qmining.frylabs.net', 'localhost' ]
  },
  main: {
    path: './modules/main.js',
    name: 'main',
    urls: [ 'frylabs.net', 'www.frylabs.net' ]
  },
  sio: {
    path: './modules/sio.js',
    name: 'sio',
    urls: [ 'sio.frylabs.net' ]
  },
  stuff: {
    path: './modules/stuff.js',
    name: 'stuff',
    urls: [ 'stuff.frylabs.net' ]
  },
  old: {
    path: './modules/old.js',
    name: 'old',
    urls: [ 'qmining.tk', 'www.qmining.tk' ]
  }
}

const app = express()

Object.keys(modules).forEach(function (k, i) {
  let x = modules[k]
  try {
    x.app = require(x.path).app
    x.urls.forEach((url) => {
      app.use(vhost(url, x.app))
    })
  } catch (e) {
    console.log(e)
  }
})

const locLogFile = './stats/logs'
const allLogFile = '/nlogs/log'

// https://certbot.eff.org/
const privkeyFile = '/etc/letsencrypt/live/frylabs.net/privkey.pem'
const fullchainFile = '/etc/letsencrypt/live/frylabs.net/fullchain.pem'
const chainFile = '/etc/letsencrypt/live/frylabs.net/chain.pem'

var certsLoaded = false
if (startHTTPS && utils.FileExists(privkeyFile) && utils.FileExists(fullchainFile) && utils.FileExists(
  chainFile)) {
  try {
    const key = fs.readFileSync(privkeyFile, 'utf8')
    const cert = fs.readFileSync(fullchainFile, 'utf8')
    const ca = fs.readFileSync(chainFile, 'utf8')
    var certs = {
      key: key,
      cert: cert,
      ca: ca
    }
    certsLoaded = true
  } catch (e) {
    logger.Log('Error loading cert files!', logger.GetColor('redbg'))
    console.log(e)
  }
}

function setLogTimer () {
  const d = new Date()
  const h = new Date(
    d.getFullYear(),
    d.getMonth(),
    d.getDate() + 1,
    0,
    0,
    0,
    0
  )
  const e = h - d

  if (e > 100) {
    setTimeout(setLogTimer, e)
  } else {
    logger.Log('Log timer malfunction :/')
  }

  const line = '-------------------------------------------------------------------------------'

  logger.Log(line)
  utils.AppendToFile(line, locLogFile)
  utils.AppendToFile(line, allLogFile)
}

setLogTimer()

app.use(function (req, res, next) {
  res.on('finish', function () {
    logger.LogReq(req, true, res.statusCode)
    let toLog = loggableKeywords.some((x) => {
      return req.url.includes(x)
    })
    if (toLog) { logger.LogReq(req) }
    if (res.statusCode !== 404) { stat.LogStat(req.url) }
  })
  next()
})

logger.Log('Node version: ' + process.version)
logger.Log('Listening on port: ' + port)

const httpServer = http.createServer(app)
httpServer.listen(port)
if (certsLoaded) {
  const httpsServer = https.createServer(certs, app)
  httpsServer.listen(httpsport)
  logger.Log('Listening on port: ' + httpsport + ' (https)')
} else {
  logger.Log('Https not avaible')
}

// app.listen(port)