592 lines
18 KiB
JavaScript
592 lines
18 KiB
JavaScript
import { Eltro as t, assert} from 'eltro'
|
|
import fs from 'fs/promises'
|
|
import HttpServer from '../core/http.mjs'
|
|
import Util from '../core/util.mjs'
|
|
import { request } from '../core/client.mjs'
|
|
import { setTimeout } from 'timers/promises'
|
|
import { prettyPrintMessage } from './helpers.mjs'
|
|
import { pipeline } from 'stream'
|
|
import getLog from '../core/log.mjs'
|
|
|
|
const util = new Util(import.meta.url)
|
|
const port = 61412
|
|
const turnDebuggingOn = false
|
|
|
|
const runners = [
|
|
['runner.mjs', 'testapp'],
|
|
['runner_cluster.mjs', 'testappcluster'],
|
|
]
|
|
|
|
runners.forEach(function([runnerName, appname]) {
|
|
t.timeout(10000).describe(runnerName, function() {
|
|
let wasSuccessful = false
|
|
let http = null
|
|
let server = null
|
|
let prefix = `http://localhost:${port}/`
|
|
let files = [util.getPathFromRoot('./testappcluster')]
|
|
let logs = []
|
|
let allLogs = []
|
|
let versions = []
|
|
let processor
|
|
let integrationLog = getLog('test.integration', [])
|
|
let compressorPath = util.getPathFromRoot('./7za.exe')
|
|
if (process.platform !== 'win32') {
|
|
compressorPath = util.getPathFromRoot('./7zas')
|
|
}
|
|
|
|
t.before(function() {
|
|
http = new HttpServer()
|
|
|
|
server = http.createServer(function(req, res) {
|
|
req.on('error', function(err) {
|
|
integrationLog.error(err, 'error')
|
|
})
|
|
res.on('error', function(err) {
|
|
integrationLog.error(err, 'error')
|
|
})
|
|
|
|
integrationLog.info('[SERVER] got request ' + req.url)
|
|
|
|
if (req.url === '/releases') {
|
|
res.statusCode = 200
|
|
let output = versions.map(x => {
|
|
return {
|
|
name: x[0],
|
|
body: x[1],
|
|
assets: [{
|
|
name: x[2],
|
|
browser_download_url: prefix + 'files/' + x[2]
|
|
}]
|
|
}
|
|
})
|
|
res.end(JSON.stringify(output));
|
|
return
|
|
} else if (req.url.startsWith('/files')) {
|
|
let filename = req.url.substring(req.url.lastIndexOf('/') + 1)
|
|
return fs.open(util.getPathFromRoot('./' + filename))
|
|
.then(function(file) {
|
|
pipeline(file.createReadStream(), res, function(err) {
|
|
if (err) {
|
|
console.log(err)
|
|
res.statusCode = 404
|
|
res.end(JSON.stringify({ error: 'unknown url' }))
|
|
}
|
|
})
|
|
}).catch(function(err) {
|
|
console.log(err)
|
|
res.statusCode = 404
|
|
res.end(JSON.stringify({ error: 'unknown url' }))
|
|
})
|
|
}
|
|
|
|
res.statusCode = 404
|
|
res.end(JSON.stringify({ error: 'unknown url' }))
|
|
})
|
|
|
|
return fs.rm(util.getPathFromRoot('./db.json'), { force: true })
|
|
.then(function() {
|
|
return server.listenAsync(port)
|
|
})
|
|
})
|
|
|
|
t.after(function() {
|
|
if (!turnDebuggingOn && !wasSuccessful) {
|
|
for (let i = 0; i < allLogs.length; i++) {
|
|
prettyPrintMessage(allLogs[i])
|
|
}
|
|
}
|
|
|
|
return Promise.all(files.map(function(file) {
|
|
return fs.rm(file, { force: true, recursive: true })
|
|
}))
|
|
.then(function() {
|
|
if (processor && !processor.exitCode) {
|
|
processor.kill()
|
|
|
|
return waitUntilClosed()
|
|
}
|
|
}).then(function() {
|
|
return http.closeServer()
|
|
})
|
|
})
|
|
|
|
const version_1_stable = `
|
|
export function start(http, port, ctx) {
|
|
const server = http.createServer(function (req, res) {
|
|
res.writeHead(200);
|
|
res.end(JSON.stringify({ version: 'v1' }))
|
|
})
|
|
|
|
return server.listenAsync(port, '0.0.0.0')
|
|
.then(() => {
|
|
ctx.log.info({ port: port, listening: true }, \`Server is listening on \${port} serving v1\`)
|
|
})
|
|
}
|
|
`
|
|
|
|
const version_2_nolisten = `
|
|
export function start(http, port, ctx) {
|
|
}
|
|
`
|
|
|
|
const version_3_crashing = `
|
|
export function start(http, port, ctx) {
|
|
process.exit(1)
|
|
}
|
|
`
|
|
|
|
const version_4_stable = `
|
|
export function start(http, port, ctx) {
|
|
const server = http.createServer(function (req, res) {
|
|
res.writeHead(200);
|
|
res.end(JSON.stringify({ version: 'v4' }))
|
|
})
|
|
|
|
return server.listenAsync(port, '0.0.0.0')
|
|
.then(() => {
|
|
ctx.log.info({ port: port, listening: true }, \`Server is listening on \${port} serving v4\`)
|
|
})
|
|
}
|
|
`
|
|
|
|
function file(relative) {
|
|
let file = util.getPathFromRoot(relative)
|
|
files.push(file)
|
|
return file
|
|
}
|
|
|
|
function log(message) {
|
|
let lines = message.split('\n')
|
|
for (let line of lines) {
|
|
if (!line.trim()) continue
|
|
logs.push(line)
|
|
allLogs.push(line)
|
|
}
|
|
}
|
|
|
|
function parseLine(line) {
|
|
if (line[0] === '{') {
|
|
try {
|
|
return JSON.parse(line)
|
|
} catch {}
|
|
}
|
|
return {
|
|
msg: line
|
|
}
|
|
}
|
|
|
|
|
|
let logIndex = 0
|
|
function catchupLog(ms = 0) {
|
|
if (logs.length > logIndex) {
|
|
for (; logIndex < logs.length; logIndex++) {
|
|
if (turnDebuggingOn) {
|
|
prettyPrintMessage(logs[logIndex])
|
|
}
|
|
}
|
|
}
|
|
if (ms > 0) {
|
|
return setTimeout(ms)
|
|
}
|
|
}
|
|
|
|
async function safeTry(func) {
|
|
let lastException = null
|
|
for (let i = 0; i < 3; i++) {
|
|
if (i > 0) {
|
|
allLogs.push('[safeTry] Failed with error ' + lastException.message + ', trying agian')
|
|
await setTimeout(500)
|
|
}
|
|
try {
|
|
await func()
|
|
return
|
|
}
|
|
catch (err) {
|
|
lastException = err
|
|
}
|
|
}
|
|
throw lastException
|
|
}
|
|
|
|
integrationLog.on('newlog', function(record) {
|
|
allLogs.push(JSON.stringify(record))
|
|
if (turnDebuggingOn) {
|
|
prettyPrintMessage(JSON.stringify(record))
|
|
}
|
|
})
|
|
|
|
let logWaitIndex = 0
|
|
function hasLogLine(regMatch) {
|
|
if (logs.length > logWaitIndex) {
|
|
for (; logWaitIndex < logs.length; logWaitIndex++) {
|
|
if (typeof(regMatch) === 'function') {
|
|
let res = regMatch(parseLine(logs[logWaitIndex]))
|
|
if (res) return true
|
|
}
|
|
else if (logs[logWaitIndex].match(regMatch)) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
function findInLogs(regMatch) {
|
|
for (let i = 0; i < logs.length; i++) {
|
|
if (typeof(regMatch) === 'function') {
|
|
let res = regMatch(parseLine(logs[i]))
|
|
if (res) return true
|
|
}
|
|
else if (logs[i].match(regMatch)) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
async function waitUntilListening() {
|
|
let listeningLine = null
|
|
while (processor.exitCode == null
|
|
&& !hasLogLine((rec) => { listeningLine = rec; return rec.listening && rec.port })) {
|
|
await catchupLog(10)
|
|
}
|
|
catchupLog()
|
|
if (listeningLine.listening && listeningLine.port) {
|
|
return listeningLine
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
|
|
async function sendRequestToApplication(listening) {
|
|
let lastErr = null
|
|
for (let i = 0; i < 4; i++) {
|
|
try {
|
|
let checkListening = await request({}, `http://localhost:${listening.port}/`)
|
|
return checkListening
|
|
} catch (err) {
|
|
lastErr = err
|
|
integrationLog.info(`Request http://localhost:${listening.port}/ failed with ${err.message} trying again in 250ms`)
|
|
await setTimeout(250)
|
|
}
|
|
}
|
|
log('-- core.test.integration.mjs crash here --')
|
|
log(lastErr.toString())
|
|
throw lastErr
|
|
}
|
|
|
|
async function waitUntilClosed(listening) {
|
|
while (true) {
|
|
catchupLog()
|
|
try {
|
|
await request({}, `http://localhost:${listening.port}/`)
|
|
} catch (err) {
|
|
break
|
|
}
|
|
await setTimeout(25)
|
|
}
|
|
catchupLog()
|
|
|
|
logs.splice(0, logs.length); logIndex = 0; logWaitIndex = 0;
|
|
if (turnDebuggingOn) { console.log('\n-------\n') }
|
|
}
|
|
|
|
function startRunner() {
|
|
return util.runCommandBackground('node', [runnerName], util.getPathFromRoot('./'), log)
|
|
}
|
|
|
|
t.test('should be fully operational', async function() {
|
|
let db;
|
|
console.log()
|
|
if (!turnDebuggingOn) { console.log('Running empty test') }
|
|
|
|
let index = file('./index.mjs')
|
|
await fs.writeFile(index, version_1_stable)
|
|
await util.runCommand(compressorPath, ['a', file('./v1-sc.7z'), index], util.getPathFromRoot('./testapp'))
|
|
|
|
processor = startRunner()
|
|
|
|
|
|
while (processor.exitCode == null) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
catchupLog()
|
|
|
|
let secondLast = parseLine(logs[logs.length - 2])
|
|
let last = parseLine(logs[logs.length - 1])
|
|
assert.match(secondLast.msg, /No/i)
|
|
assert.match(secondLast.msg, /versions/i)
|
|
assert.match(secondLast.msg, /found/i)
|
|
assert.match(last.msg, /starting/i)
|
|
assert.match(last.msg, /runner/i)
|
|
assert.match(last.err.message, /stable/i)
|
|
assert.match(last.err.message, /application/i)
|
|
|
|
// Reset our log
|
|
logs.splice(0, logs.length); logIndex = 0; logWaitIndex = 0;
|
|
if (turnDebuggingOn) { console.log('\n-------\n') }
|
|
|
|
const assertNameVersion1 = 'v1_ok'
|
|
|
|
if (!turnDebuggingOn) { console.log(`Running update ${assertNameVersion1} test`) }
|
|
|
|
file(`./testapp/${assertNameVersion1}`)
|
|
|
|
versions.splice(0, 0, [assertNameVersion1, 'ok version', 'v1-sc.7z'])
|
|
processor = startRunner()
|
|
|
|
let listening = await waitUntilListening()
|
|
|
|
let checkListening = await sendRequestToApplication(listening)
|
|
assert.strictEqual(checkListening.body.version, 'v1')
|
|
|
|
while (!hasLogLine(/is up and running/)) {
|
|
await setTimeout(10)
|
|
if (processor.exitCode !== null) {
|
|
throw new Error('Process exited with ' + processor.exitCode)
|
|
}
|
|
}
|
|
|
|
await setTimeout(50)
|
|
|
|
catchupLog()
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion1)
|
|
assert.strictEqual(db.core[appname].versions.length, 1)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, 1)
|
|
assert.strictEqual(db.core[appname].versions[0].installed, true)
|
|
})
|
|
|
|
// Create our second version
|
|
await fs.writeFile(index, version_2_nolisten)
|
|
await util.runCommand(compressorPath, ['a', file('./v2-sc.7z'), index], util.getPathFromRoot('./testapp'))
|
|
|
|
const assertNameVersion2 = 'v2_nolisten'
|
|
if (!turnDebuggingOn) { console.log(`Running update ${assertNameVersion2} test`) }
|
|
file(`./testapp/${assertNameVersion2}`)
|
|
versions.splice(0, 0, [assertNameVersion2, 'no listen version', 'v2-sc.7z'])
|
|
|
|
// wait a second for it to trigger an update
|
|
|
|
await setTimeout(500)
|
|
|
|
while (!hasLogLine(/Error starting v2_nolisten/)) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
if (appname !== 'testappcluster') {
|
|
while (!hasLogLine(/restart.*v2_nolisten.*dirty/)) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
while (processor.exitCode == null) {
|
|
await catchupLog(10)
|
|
}
|
|
catchupLog()
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion2)
|
|
assert.strictEqual(db.core[appname].versions.length, 2)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, -1)
|
|
assert.strictEqual(db.core[appname].versions[0].installed, true)
|
|
assert.strictEqual(db.core[appname].versions[1].stable, 1)
|
|
assert.strictEqual(db.core[appname].versions[1].installed, true)
|
|
})
|
|
|
|
// Since application was in dirty state, on next attempt should attempt to
|
|
// run v2 again and then falling back to v1
|
|
|
|
await waitUntilClosed()
|
|
|
|
if (!turnDebuggingOn) { console.log(`Running fresh ${assertNameVersion2} test`) }
|
|
processor = startRunner()
|
|
await catchupLog(10)
|
|
|
|
while (!hasLogLine(/Attempting to run version v2_nolisten/)) {
|
|
await catchupLog(10)
|
|
}
|
|
}
|
|
|
|
while (!hasLogLine(/Attempting to run version v1_ok/)) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
listening = await waitUntilListening()
|
|
assert.ok(listening)
|
|
checkListening = await sendRequestToApplication(listening)
|
|
assert.strictEqual(checkListening.body.version, 'v1')
|
|
|
|
while (!hasLogLine(/is up and running/)) {
|
|
await setTimeout(10)
|
|
}
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion1)
|
|
assert.strictEqual(db.core[appname].versions.length, 2)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, -2)
|
|
assert.strictEqual(db.core[appname].versions[1].stable, 1)
|
|
})
|
|
|
|
assert.ok(findInLogs(/Attempting to run version v2_nolisten/))
|
|
assert.ok(findInLogs(/Error starting v2_nolisten/))
|
|
|
|
processor.kill()
|
|
|
|
if (!turnDebuggingOn) { console.log(`Running version stability check test`) }
|
|
|
|
await waitUntilClosed()
|
|
processor = startRunner()
|
|
|
|
listening = await waitUntilListening()
|
|
|
|
assert.ok(listening)
|
|
|
|
checkListening = await sendRequestToApplication(listening)
|
|
assert.strictEqual(checkListening.body.version, 'v1')
|
|
|
|
while (!hasLogLine(/is up and running/)) {
|
|
await setTimeout(10)
|
|
}
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion1)
|
|
assert.strictEqual(db.core[appname].versions.length, 2)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, -2)
|
|
assert.strictEqual(db.core[appname].versions[1].stable, 1)
|
|
})
|
|
|
|
assert.notOk(findInLogs(/Attempting to run version v2_nolisten/))
|
|
assert.notOk(findInLogs(/Error starting v2_nolisten/))
|
|
|
|
// Create our third version
|
|
await fs.writeFile(index, version_3_crashing)
|
|
await util.runCommand(compressorPath, ['a', file('./v3-sc.7z'), index], util.getPathFromRoot('./testapp'))
|
|
|
|
const assertNameVersion3 = 'v3_crash'
|
|
if (!turnDebuggingOn) { console.log(`Running update ${assertNameVersion3} test`) }
|
|
file(`./testapp/${assertNameVersion3}`)
|
|
versions.splice(0, 0, [assertNameVersion3, 'crash version', 'v3-sc.7z'])
|
|
|
|
// wait a second for it to trigger an update
|
|
|
|
await setTimeout(500)
|
|
|
|
while (!hasLogLine(/Attempting to run version v3_crash/)) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
if (appname !== 'testappcluster') {
|
|
while (processor.exitCode == null) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion3)
|
|
assert.strictEqual(db.core[appname].versions.length, 3)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, -2)
|
|
assert.strictEqual(db.core[appname].versions[1].stable, -2)
|
|
assert.strictEqual(db.core[appname].versions[2].stable, 1)
|
|
})
|
|
|
|
catchupLog()
|
|
|
|
// Should recover afterwards
|
|
await waitUntilClosed()
|
|
processor = startRunner()
|
|
|
|
listening = await waitUntilListening()
|
|
|
|
assert.ok(listening)
|
|
|
|
checkListening = await sendRequestToApplication(listening)
|
|
assert.strictEqual(checkListening.body.version, 'v1')
|
|
|
|
while (!hasLogLine(/core is running/)) {
|
|
await setTimeout(10)
|
|
}
|
|
} else {
|
|
while (!hasLogLine(/Attempting to run version v1_ok/)) {
|
|
await catchupLog(10)
|
|
}
|
|
while (!hasLogLine(/is up and running/)) {
|
|
await setTimeout(10)
|
|
}
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion1)
|
|
assert.strictEqual(db.core[appname].versions.length, 3)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, -2)
|
|
assert.strictEqual(db.core[appname].versions[1].stable, -2)
|
|
assert.strictEqual(db.core[appname].versions[2].stable, 1)
|
|
})
|
|
}
|
|
|
|
// Create our fourth version
|
|
await fs.writeFile(index, version_4_stable)
|
|
await util.runCommand(compressorPath, ['a', file('./v4-sc.7z'), index], util.getPathFromRoot('./testapp'))
|
|
|
|
const assertNameVersion4 = 'v4_stable'
|
|
if (!turnDebuggingOn) { console.log(`Running update ${assertNameVersion4} test`) }
|
|
file(`./testapp/${assertNameVersion4}`)
|
|
versions.splice(0, 0, [assertNameVersion4, 'no listen version', 'v4-sc.7z'])
|
|
|
|
// wait a second for it to trigger an update
|
|
|
|
await setTimeout(500)
|
|
|
|
while (!hasLogLine(/Attempting to run version v4_stable/)) {
|
|
await catchupLog(10)
|
|
}
|
|
|
|
while (!hasLogLine(/Server is listening on 31313 serving v4/)) {
|
|
await catchupLog(10)
|
|
}
|
|
while (!hasLogLine(/is up and running/)) {
|
|
await setTimeout(10)
|
|
}
|
|
|
|
catchupLog()
|
|
|
|
checkListening = await sendRequestToApplication(listening)
|
|
assert.strictEqual(checkListening.body.version, 'v4')
|
|
|
|
await setTimeout(10)
|
|
|
|
await safeTry(async function() {
|
|
db = JSON.parse(await fs.readFile(util.getPathFromRoot('./db.json')))
|
|
assert.strictEqual(db.core[appname].active, assertNameVersion4)
|
|
assert.strictEqual(db.core[appname].versions.length, 4)
|
|
assert.strictEqual(db.core[appname].versions[0].stable, 1)
|
|
assert.strictEqual(db.core[appname].versions[1].stable, -2)
|
|
})
|
|
|
|
if (appname === 'testappcluster') {
|
|
let foundCore = false
|
|
let foundWorker = false
|
|
for (let line of allLogs) {
|
|
if (line.startsWith('[FROMWORKERCORE] test-runner-cluster')) {
|
|
foundCore = true
|
|
}
|
|
else if (line.startsWith('[FROMWORKERAPP] testappcluster-1')) {
|
|
foundWorker = true
|
|
}
|
|
if (foundCore && foundWorker) {
|
|
break
|
|
}
|
|
}
|
|
|
|
assert.ok(foundCore)
|
|
assert.ok(foundWorker)
|
|
}
|
|
wasSuccessful = true
|
|
})
|
|
})
|
|
})
|