This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
314 lines
6.7 KiB
314 lines
6.7 KiB
'use strict'; |
|
const childProcess = require('child_process'); |
|
const util = require('util'); |
|
const crossSpawn = require('cross-spawn'); |
|
const stripEof = require('strip-eof'); |
|
const npmRunPath = require('npm-run-path'); |
|
const isStream = require('is-stream'); |
|
const _getStream = require('get-stream'); |
|
const pFinally = require('p-finally'); |
|
const onExit = require('signal-exit'); |
|
const errname = require('./lib/errname'); |
|
const stdio = require('./lib/stdio'); |
|
|
|
const TEN_MEGABYTES = 1000 * 1000 * 10; |
|
|
|
function handleArgs(cmd, args, opts) { |
|
let parsed; |
|
|
|
opts = Object.assign({ |
|
extendEnv: true, |
|
env: {} |
|
}, opts); |
|
|
|
if (opts.extendEnv) { |
|
opts.env = Object.assign({}, process.env, opts.env); |
|
} |
|
|
|
if (opts.__winShell === true) { |
|
delete opts.__winShell; |
|
parsed = { |
|
command: cmd, |
|
args, |
|
options: opts, |
|
file: cmd, |
|
original: cmd |
|
}; |
|
} else { |
|
parsed = crossSpawn._parse(cmd, args, opts); |
|
} |
|
|
|
opts = Object.assign({ |
|
maxBuffer: TEN_MEGABYTES, |
|
stripEof: true, |
|
preferLocal: true, |
|
localDir: parsed.options.cwd || process.cwd(), |
|
encoding: 'utf8', |
|
reject: true, |
|
cleanup: true |
|
}, parsed.options); |
|
|
|
opts.stdio = stdio(opts); |
|
|
|
if (opts.preferLocal) { |
|
opts.env = npmRunPath.env(Object.assign({}, opts, {cwd: opts.localDir})); |
|
} |
|
|
|
return { |
|
cmd: parsed.command, |
|
args: parsed.args, |
|
opts, |
|
parsed |
|
}; |
|
} |
|
|
|
function handleInput(spawned, opts) { |
|
const input = opts.input; |
|
|
|
if (input === null || input === undefined) { |
|
return; |
|
} |
|
|
|
if (isStream(input)) { |
|
input.pipe(spawned.stdin); |
|
} else { |
|
spawned.stdin.end(input); |
|
} |
|
} |
|
|
|
function handleOutput(opts, val) { |
|
if (val && opts.stripEof) { |
|
val = stripEof(val); |
|
} |
|
|
|
return val; |
|
} |
|
|
|
function handleShell(fn, cmd, opts) { |
|
let file = '/bin/sh'; |
|
let args = ['-c', cmd]; |
|
|
|
opts = Object.assign({}, opts); |
|
|
|
if (process.platform === 'win32') { |
|
opts.__winShell = true; |
|
file = process.env.comspec || 'cmd.exe'; |
|
args = ['/s', '/c', `"${cmd}"`]; |
|
opts.windowsVerbatimArguments = true; |
|
} |
|
|
|
if (opts.shell) { |
|
file = opts.shell; |
|
delete opts.shell; |
|
} |
|
|
|
return fn(file, args, opts); |
|
} |
|
|
|
function getStream(process, stream, encoding, maxBuffer) { |
|
if (!process[stream]) { |
|
return null; |
|
} |
|
|
|
let ret; |
|
|
|
if (encoding) { |
|
ret = _getStream(process[stream], { |
|
encoding, |
|
maxBuffer |
|
}); |
|
} else { |
|
ret = _getStream.buffer(process[stream], {maxBuffer}); |
|
} |
|
|
|
return ret.catch(err => { |
|
err.stream = stream; |
|
err.message = `${stream} ${err.message}`; |
|
throw err; |
|
}); |
|
} |
|
|
|
module.exports = (cmd, args, opts) => { |
|
let joinedCmd = cmd; |
|
|
|
if (Array.isArray(args) && args.length > 0) { |
|
joinedCmd += ' ' + args.join(' '); |
|
} |
|
|
|
const parsed = handleArgs(cmd, args, opts); |
|
const encoding = parsed.opts.encoding; |
|
const maxBuffer = parsed.opts.maxBuffer; |
|
|
|
let spawned; |
|
try { |
|
spawned = childProcess.spawn(parsed.cmd, parsed.args, parsed.opts); |
|
} catch (err) { |
|
return Promise.reject(err); |
|
} |
|
|
|
let removeExitHandler; |
|
if (parsed.opts.cleanup) { |
|
removeExitHandler = onExit(() => { |
|
spawned.kill(); |
|
}); |
|
} |
|
|
|
let timeoutId = null; |
|
let timedOut = false; |
|
|
|
const cleanupTimeout = () => { |
|
if (timeoutId) { |
|
clearTimeout(timeoutId); |
|
timeoutId = null; |
|
} |
|
}; |
|
|
|
if (parsed.opts.timeout > 0) { |
|
timeoutId = setTimeout(() => { |
|
timeoutId = null; |
|
timedOut = true; |
|
spawned.kill(parsed.opts.killSignal); |
|
}, parsed.opts.timeout); |
|
} |
|
|
|
const processDone = new Promise(resolve => { |
|
spawned.on('exit', (code, signal) => { |
|
cleanupTimeout(); |
|
resolve({code, signal}); |
|
}); |
|
|
|
spawned.on('error', err => { |
|
cleanupTimeout(); |
|
resolve({err}); |
|
}); |
|
|
|
if (spawned.stdin) { |
|
spawned.stdin.on('error', err => { |
|
cleanupTimeout(); |
|
resolve({err}); |
|
}); |
|
} |
|
}); |
|
|
|
function destroy() { |
|
if (spawned.stdout) { |
|
spawned.stdout.destroy(); |
|
} |
|
|
|
if (spawned.stderr) { |
|
spawned.stderr.destroy(); |
|
} |
|
} |
|
|
|
const handlePromise = () => pFinally(Promise.all([ |
|
processDone, |
|
getStream(spawned, 'stdout', encoding, maxBuffer), |
|
getStream(spawned, 'stderr', encoding, maxBuffer) |
|
]).then(arr => { |
|
const result = arr[0]; |
|
const stdout = arr[1]; |
|
const stderr = arr[2]; |
|
|
|
let err = result.err; |
|
const code = result.code; |
|
const signal = result.signal; |
|
|
|
if (removeExitHandler) { |
|
removeExitHandler(); |
|
} |
|
|
|
if (err || code !== 0 || signal !== null) { |
|
if (!err) { |
|
let output = ''; |
|
|
|
if (Array.isArray(parsed.opts.stdio)) { |
|
if (parsed.opts.stdio[2] !== 'inherit') { |
|
output += output.length > 0 ? stderr : `\n${stderr}`; |
|
} |
|
|
|
if (parsed.opts.stdio[1] !== 'inherit') { |
|
output += `\n${stdout}`; |
|
} |
|
} else if (parsed.opts.stdio !== 'inherit') { |
|
output = `\n${stderr}${stdout}`; |
|
} |
|
|
|
err = new Error(`Command failed: ${joinedCmd}${output}`); |
|
err.code = code < 0 ? errname(code) : code; |
|
} |
|
|
|
// TODO: missing some timeout logic for killed |
|
// https://github.com/nodejs/node/blob/master/lib/child_process.js#L203 |
|
// err.killed = spawned.killed || killed; |
|
err.killed = err.killed || spawned.killed; |
|
|
|
err.stdout = stdout; |
|
err.stderr = stderr; |
|
err.failed = true; |
|
err.signal = signal || null; |
|
err.cmd = joinedCmd; |
|
err.timedOut = timedOut; |
|
|
|
if (!parsed.opts.reject) { |
|
return err; |
|
} |
|
|
|
throw err; |
|
} |
|
|
|
return { |
|
stdout: handleOutput(parsed.opts, stdout), |
|
stderr: handleOutput(parsed.opts, stderr), |
|
code: 0, |
|
failed: false, |
|
killed: false, |
|
signal: null, |
|
cmd: joinedCmd, |
|
timedOut: false |
|
}; |
|
}), destroy); |
|
|
|
crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed); |
|
|
|
handleInput(spawned, parsed.opts); |
|
|
|
spawned.then = (onfulfilled, onrejected) => handlePromise().then(onfulfilled, onrejected); |
|
spawned.catch = onrejected => handlePromise().catch(onrejected); |
|
|
|
return spawned; |
|
}; |
|
|
|
module.exports.stdout = function () { |
|
// TODO: set `stderr: 'ignore'` when that option is implemented |
|
return module.exports.apply(null, arguments).then(x => x.stdout); |
|
}; |
|
|
|
module.exports.stderr = function () { |
|
// TODO: set `stdout: 'ignore'` when that option is implemented |
|
return module.exports.apply(null, arguments).then(x => x.stderr); |
|
}; |
|
|
|
module.exports.shell = (cmd, opts) => handleShell(module.exports, cmd, opts); |
|
|
|
module.exports.sync = (cmd, args, opts) => { |
|
const parsed = handleArgs(cmd, args, opts); |
|
|
|
if (isStream(parsed.opts.input)) { |
|
throw new TypeError('The `input` option cannot be a stream in sync mode'); |
|
} |
|
|
|
const result = childProcess.spawnSync(parsed.cmd, parsed.args, parsed.opts); |
|
|
|
if (result.error || result.status !== 0) { |
|
throw (result.error || new Error(result.stderr === '' ? result.stdout : result.stderr)); |
|
} |
|
|
|
result.stdout = handleOutput(parsed.opts, result.stdout); |
|
result.stderr = handleOutput(parsed.opts, result.stderr); |
|
|
|
return result; |
|
}; |
|
|
|
module.exports.shellSync = (cmd, opts) => handleShell(module.exports.sync, cmd, opts); |
|
|
|
module.exports.spawn = util.deprecate(module.exports, 'execa.spawn() is deprecated. Use execa() instead.');
|
|
|