TheThing/service-core
1
0
Fork 0
Code Issues Pull requests Projects Releases 22 Wiki Activity

Implemented basic service core support

Browse source
This commit is contained in:
Jonatan Nilsson 2020-09-09 15:41:05 +00:00
parent 9f0dddc5ad
commit 4b274445ca
7 changed files with 211 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
config.json
View file

@ -3,7 +3,8 @@
"serviceName": "Service-Core Node",
"description": "NodeJS Test Service",
"port": 4270,
"managePort": 4269,
"managePort": 4271,
"devPort": 4269,
"appRepository": "thething/sc-helloworld",
"manageRepository": null
}

186
core/core.mjs
View file

@ -1,26 +1,28 @@
import fs from 'fs'
import { EventEmitter } from 'events'
import { request } from './client.mjs'
import HttpServer from './http.mjs'
const fsp = fs.promises
export default class Core extends EventEmitter{
constructor(util, config, db, log, closeCb) {
super()
this._util = util
this._config = config
this._db = db
this._log = log
this.http = new HttpServer()
this.util = util
this.config = config
this.db = db
this.log = log
this._close = closeCb
this._appRunning = false
this._manageRunning = false
this.appRunning = false
this.manageRunning = false
this._appUpdating = {
status: false,
updating: false,
starting: false,
logs: '',
}
this._manageUpdating = {
status: false,
updating: false,
starting: false,
logs: '',
}
@ -32,19 +34,21 @@ export default class Core extends EventEmitter{
status() {
return {
app: this._appRunning,
manage: this._manageRunning,
appUpdating: this._appUpdating.status,
manageUpdating: this._manageUpdating.status,
app: this.appRunning,
manage: this.manageRunning,
appUpdating: this._appUpdating.updating,
manageUpdating: this._manageUpdating.updating,
appStarting: this._appUpdating.starting,
manageStarting: this._manageUpdating.starting,
}
}
async getLatestVersion(active, name) {
// Example: 'https://api.github.com/repos/thething/sc-helloworld/releases'
this.logActive(name, active, `[Core] Fetching release info from: https://api.github.com/repos/${this._config[name + 'Repository']}/releases\n`)
this.logActive(name, active, `[Core] Fetching release info from: https://api.github.com/repos/${this.config[name + 'Repository']}/releases\n`)
let result = await request(`https://api.github.com/repos/${this._config[name + 'Repository']}/releases`)
let result = await request(`https://api.github.com/repos/${this.config[name + 'Repository']}/releases`)
let items = result.body.filter(function(item) {
if (!item.assets.length) return false
@ -60,7 +64,7 @@ export default class Core extends EventEmitter{
if (item.assets[i].name.endsWith('-sc.zip')) {
this.logActive(name, active, `[Core] Found version ${item.name} with file ${item.assets[i].name}\n`)
await this._db.set(`core.${name}LatestVersion`, item.name)
await this.db.set(`core.${name}LatestVersion`, item.name)
.write()
this.emit('dbupdated', {})
@ -80,7 +84,7 @@ export default class Core extends EventEmitter{
logActive(name, active, logline, doNotPrint = false) {
if (!doNotPrint) {
this._log.info(`Log ${name}: ` + logline.replace(/\n/g, ''))
this.log.info(`Log ${name}: ` + logline.replace(/\n/g, ''))
}
active.logs += logline
this.emit(name + 'log', active)
@ -93,57 +97,57 @@ export default class Core extends EventEmitter{
return this._manageUpdating.logs
}
let latestInstalled = this._db.get('core.' + name + 'LatestInstalled').value()
let latestVersion = this._db.get('core.' + name + 'LatestVersion').value()
let latestInstalled = this.db.get('core.' + name + 'LatestInstalled').value()
let latestVersion = this.db.get('core.' + name + 'LatestVersion').value()
if (latestVersion) {
let value = this._db.get(`core_${name}History`).getById(latestVersion).value()
let value = this.db.get(`core_${name}History`).getById(latestVersion).value()
if (value) return value.logs
}
if (latestInstalled) {
let value = this._db.get(`core_${name}History`).getById(latestInstalled).value()
let value = this.db.get(`core_${name}History`).getById(latestInstalled).value()
if (value) return value.logs
}
return '< no logs found >'
}
async installVersion(name, active, version) {
if (fs.existsSync(this._util.getPathFromRoot(`./${name}/` + version.name))) {
await this._util.runCommand('rmdir', ['/S', '/Q', `"${this._util.getPathFromRoot(`./${name}/` + version.name)}"`])
if (fs.existsSync(this.util.getPathFromRoot(`./${name}/` + version.name))) {
await this.util.runCommand('rmdir', ['/S', '/Q', `"${this.util.getPathFromRoot(`./${name}/` + version.name)}"`])
}
try {
await fsp.mkdir(this._util.getPathFromRoot(`./${name}/` + version.name))
await fsp.mkdir(this.util.getPathFromRoot(`./${name}/` + version.name))
} catch(err) {
if (err.code !== 'EEXIST') {
throw err
}
}
// await fsp.mkdir(this._util.getPathFromRoot(`./${name}/` + version.name + '/node_modules'))
// await fsp.mkdir(this.util.getPathFromRoot(`./${name}/` + version.name + '/node_modules'))
this.logActive(name, active, `[Core] Downloading ${version.name} (${version.url}) to ${version.name + '/' + version.name + '.zip'}\n`)
let filePath = this._util.getPathFromRoot(`./${name}/` + version.name + '/' + version.name + '.zip')
let filePath = this.util.getPathFromRoot(`./${name}/` + version.name + '/' + version.name + '.zip')
await request(version.url, filePath)
this.logActive(name, active, `[Core] Downloading finished, starting extraction\n`)
await this._util.runCommand(
await this.util.runCommand(
'"C:\\Program Files\\7-Zip\\7z.exe"',
['x', `"${filePath}"`],
this._util.getPathFromRoot(`./${name}/` + version.name + '/'),
this.util.getPathFromRoot(`./${name}/` + version.name + '/'),
this.logActive.bind(this, name, active)
)
if (!fs.existsSync(this._util.getPathFromRoot(`./${name}/` + version.name + '/index.mjs'))) {
if (!fs.existsSync(this.util.getPathFromRoot(`./${name}/` + version.name + '/index.mjs'))) {
this.logActive(name, active, `\n[Core] ERROR: Missing index.mjs in the folder, exiting\n`)
throw new Error(`Missing index.mjs in ${this._util.getPathFromRoot(`./${name}/` + version.name + '/index.mjs')}`)
throw new Error(`Missing index.mjs in ${this.util.getPathFromRoot(`./${name}/` + version.name + '/index.mjs')}`)
}
this.logActive(name, active, `\n[Core] Starting npm install\n`)
await this._util.runCommand(
await this.util.runCommand(
'npm.cmd',
['install', '--production', '--no-optional', '--no-package-lock', '--no-audit'],
this._util.getPathFromRoot(`./${name}/` + version.name + '/'),
this.util.getPathFromRoot(`./${name}/` + version.name + '/'),
this.logActive.bind(this, name, active)
)
await this._db.set(`core.${name}LatestInstalled`, version.name)
await this.db.set(`core.${name}LatestInstalled`, version.name)
.write()
this.emit('dbupdated', {})
@ -160,35 +164,67 @@ export default class Core extends EventEmitter{
}
}
async startProgram(name) {
async startModule(module, port) {
let out = await module.start(this.config, this.db, this.log, this, this.http, port)
if (out && out.then) {
await out
}
if (!this.http.getCurrentServer()) {
this.log.warn('Module did not call http.createServer')
}
}
async tryStartProgram(name) {
let active = this.getActive(name)
if ((name === 'app' && this._appRunning)
|| (name === 'manage' && this._manageRunning)
if ((name === 'app' && this.appRunning)
|| (name === 'manage' && this.manageRunning)
|| active.starting) {
this._log.event.warn('Attempting to start ' + name + ' which is already running')
this._log.warn('Attempting to start ' + name + ' which is already running')
this.log.event.warn('Attempting to start ' + name + ' which is already running')
this.log.warn('Attempting to start ' + name + ' which is already running')
this.logActive(name, active, `[${name}] Attempting to start it but it is already running\n`, true)
return
}
active.starting = true
let core = this._db.get('core').value()
let version = core[name + 'LatestInstalled']
if (await this.tryStartProgram(name, active, version)) return
version = core[name + 'LastActive']
if (await this.tryStartProgram(name, active,version)) return
let history = this.db.get(`core_${name}History`)
.filter('installed')
.orderBy('installed', 'desc')
.value()
this._log.error('Unable to start ' + name)
this._log.event.error('Unable to start ' + name)
for (let i = 0; i < history.length; i++) {
if (history[i].stable < 0) continue
await this.db.set(`core.${name}Active`, history[i].name)
.write()
this.emit('dbupdated', {})
let running = await this.tryStartProgramVersion(name, active, history[i].name)
if (running) {
history[i].stable = 1
} else {
history[i].stable = -1
await this.db.set(`core.${name}Active`, null)
.write()
this.emit('dbupdated', {})
}
await this.db.get(`core_${name}History`).updateById(history[i].id, history[i].stable).write()
if (history[i].stable > 0) break
}
if (!this.db.get(`core.${name}Active`).value()) {
this.log.error('Unable to start ' + name)
this.log.event.error('Unable to start ' + name)
}
active.starting = false
}
async tryStartProgram(name, active, version) {
async tryStartProgramVersion(name, active, version) {
if (!version) return false
this.logActive(name, active, `[${name}] Attempting to start ${version}\n`)
let indexPath = this._util.getUrlFromRoot(`./${name}/` + version + '/index.mjs')
let indexPath = this.util.getUrlFromRoot(`./${name}/` + version + '/index.mjs')
let module
try {
@ -197,49 +233,50 @@ export default class Core extends EventEmitter{
} catch (err) {
this.logActive(name, active, `[${name}] Error importing module\n`, true)
this.logActive(name, active, `[${name}] ${err.stack}\n`, true)
this._log.error(err, `Failed to load ${indexPath}`)
this.log.error(err, `Failed to load ${indexPath}`)
return false
}
let checkTimeout = null
try {
await new Promise((res, rej) => {
try {
let checkTimeout = setTimeout(function() {
rej(new Error('Program took longer than 60 seconds to resolve promise'))
}, 60 * 1000)
this.logActive(name, active, `[${name}] Starting module\n`)
let out = module.start(this._config, this._db, this._log, this)
if (out.then) {
return out.then(res, rej)
} else {
res()
}
try {
this.http.setContext(name)
this.startModule(module, name === 'app' ? this.config.port : this.config.managePort)
.then(res, rej)
} catch (err) {
rej(err)
}
})
} catch (err) {
clearTimeout(checkTimeout)
await this.http.closeServer(name)
this.logActive(name, active, `[${name}] Error starting\n`, true)
this.logActive(name, active, `[${name}] ${err.stack}\n`, true)
this._log.error(err, `Failed to start ${name}`)
this.log.error(err, `Failed to start ${name}`)
return false
}
clearTimeout(checkTimeout)
this.logActive(name, active, `[${name}] Successfully started version ${version}\n`)
await this._db.set(`core.${name}Active`, version)
await this.db.set(`core.${name}Active`, version)
.write()
let port = name === 'app' ? this._config.port : this._config.managePort
let port = name === 'app' ? this.config.port : this.config.managePort
this.logActive(name, active, `[${name}] Checking if listening to port ${port}\n`)
if (name === 'app') {
this._appRunning = true
this.appRunning = true
} else {
this._manageRunning = true
this.manageRunning = true
}
this.emit('statusupdated', {})
this.logActive(name, active, `[${name}] Module is running successfully\n`)
@ -247,20 +284,19 @@ export default class Core extends EventEmitter{
}
async updateProgram(name) {
if (!this._config[name + 'Repository']) {
if (!this.config[name + 'Repository']) {
if (name === 'app') {
this._log.error(name + 'Repository was missing from config')
this._log.event.error(name + 'Repository was missing from config')
this.log.error(name + 'Repository was missing from config')
this.log.event.error(name + 'Repository was missing from config')
} else {
this._log.warn(name + 'Repository was missing from config')
this._log.event.warn(name + 'Repository was missing from config')
this.log.warn(name + 'Repository was missing from config')
this.log.event.warn(name + 'Repository was missing from config')
}
return
}
let active = this.getActive(name)
active.status = true
active.logs = ''
active.updating = true
this.emit('statusupdated', {})
this.logActive(name, active, `[Core] Time: ${new Date().toISOString().replace('T', ' ').split('.')[0]}\n`)
@ -271,9 +307,8 @@ export default class Core extends EventEmitter{
let found = false
try {
version = await this.getLatestVersion(active, name)
let core = this._db.get('core').value()
let fromDb = this._db.get(`core_${name}History`).getById(version.name).value()
console.log(fromDb)
let core = this.db.get('core').value()
let fromDb = this.db.get(`core_${name}History`).getById(version.name).value()
if (!fromDb || !fromDb.installed) {
let oldVersion = core[name + 'Current'] || '<none>'
this.logActive(name, active, `[Core] Updating from ${oldVersion} to ${version.name}\n`)
@ -282,17 +317,17 @@ export default class Core extends EventEmitter{
installed = new Date()
} else {
found = true
this.logActive(name, active, `[Core] Version ${version.name} already installed\n\n[Core] Logs from previous install:\n----------------------------------\n\n${fromDb.logs}\n----------------------------------\n[Core] Old logs finished`)
this.logActive(name, active, `[Core] Version ${version.name} already installed\n`)
}
} catch(err) {
this.logActive(name, active, '\n', true)
this.logActive(name, active, `[Error] Exception occured while updating ${name}\n`, true)
this.logActive(name, active, err.stack, true)
this._log.error(err, 'Error while updating ' + name)
this.log.error(err, 'Error while updating ' + name)
}
active.status = false
active.updating = false
if (version && !found) {
await this._db.get(`core_${name}History`).upsert({
await this.db.get(`core_${name}History`).upsert({
id: version.name,
name: version.name,
filename: version.filename,
@ -308,8 +343,9 @@ export default class Core extends EventEmitter{
async start(name) {
await this.updateProgram(name)
if (core[name + 'CurrentVersion']) {
await this.startProgram(name)
var version = this.db.get('core.' + name + 'LatestVersion').value()
if (version) {
await this.tryStartProgram(name)
}
}
}

2
core/db.mjs
View file

@ -141,11 +141,9 @@ export default function GetDB(util, log) {
db.defaults({
core: {
"appActive": null, // Current active running
"appLastActive": null, // Last active stable running
"appLatestInstalled": null, // Latest installed version
"appLatestVersion": null, // Newest version available
"manageActive": null,
"manageLastActive": null,
"manageLatestInstalled": null,
"manageLatestVersion": null
},

66
core/http.mjs Normal file
View file

@ -0,0 +1,66 @@
import http from 'http'
export default class HttpServer {
constructor() {
this.active = {
app: false,
manage: false,
dev: false,
}
this.sockets = {
app: new Set(),
manage: new Set(),
dev: new Set(),
}
this._context = 'dev'
}
setContext(name) {
if (name !== 'app' && name !== 'manage' && name !== 'dev') {
throw new Error('Cannot call setContext with values other than app or manage')
}
}
createServer(opts, listener) {
return this._createServer(this._context, opts, listener)
}
_createServer(name, opts, listener) {
let server = http.createServer(opts, listener)
server.on('connection', (socket) => {
this.sockets[name].add(socket)
socket.once('close', () => {
this.sockets[name].delete(socket)
})
})
this.active[name] = server
return server
}
getServer(name) {
return this.active[name]
}
closeServer(name) {
if (!this.active[name]) return
return new Promise((res, rej) => {
this.sockets[name].forEach(function(socket) {
socket.destroy()
})
this.sockets[name].clear()
this.active[name].close(function(err) {
if (err) return rej(err)
res()
})
})
}
getCurrentServer() {
return this.active[this._context]
}
}

17
lib.mjs
View file

@ -1,7 +1,8 @@
import Util from './core/util.mjs'
import { readFileSync } from 'fs'
import { getLog } from './core/log.mjs'
import getLog from './core/log.mjs'
import lowdb from './core/db.mjs'
import Core from './core/core.mjs'
export default class ServiceCore {
constructor(name, root_import_meta_url) {
@ -18,14 +19,14 @@ export default class ServiceCore {
close(err) {
if (err) {
log.fatal(err, 'App recorded a fatal error')
this.log.fatal(err, 'App recorded a fatal error')
process.exit(4)
}
log.warn('App asked to be restarted')
this.log.warn('App asked to be restarted')
process.exit(0)
}
async init() {
async init(module = null) {
try {
this.config = JSON.parse(readFileSync(this.util.getPathFromRoot('./config.json')))
} catch (err) {
@ -39,9 +40,13 @@ export default class ServiceCore {
}
this.core = new Core(this.util, this.config, this.db, this.log, (err) => this.close(err))
if (module) {
return this.startModule(module)
}
}
async startModule(module) {
return module.start(config, db, log, core)
startModule(module) {
return this.core.startModule(module, this.config.devPort)
}
}

2
package.json
View file

@ -2,7 +2,7 @@
"name": "service-core",
"version": "1.0.0",
"description": "Core boiler plate code to install node server as windows service",
"main": "lib.js",
"main": "lib.mjs",
"scripts": {
"dev": "nodemon --watch dev/api --watch core --watch runner.mjs --watch db.mjs --watch log.mjs runner.mjs | bunyan",
"test": "echo \"Error: no test specified\" && exit 1"

22
runner.mjs
View file

@ -35,13 +35,23 @@ const close = function(err) {
const util = new Util(import.meta.url)
lowdb(util, log).then(function(db) {
lowdb(util, log).then(async function(db) {
let core = new Core(util, config, db, log, close)
if (config.useDev) {
return import('./dev/index.mjs').then(function(module) {
return module.start(config, db, log, core)
})
let errors = 0
try {
await core.start('app')
} catch (err) {
log.error(err, 'Unable to start app')
errors++
}
try {
await core.start('manage')
} catch (err) {
log.error(err, 'Unable to start manage')
errors++
}
if (errors === 2 || (!core.appRunning && !core.manageRunning)) {
throw new Error('Neither manage or app were started, exiting.')
}
}, function(err) {
log.fatal(err, 'Critical error opening database')