Contextify : How to catch async errors - node.js

I need to run unsafe JS script in node and be able to recover from errors.
The script can use async functions so I use contextify instead of node built in VM module.
The problem is that errors in async code in the script crash the node process.
Here is my test :
var contextify = require('contextify');
var context = {
console:{
log:function(msg){
console.log('Contextify : '+msg);
}
},
setTimeout:setTimeout
};
console.log("begin test");
contextify(context);
try{ // try to run unsafe script
//context.run("console.log('Sync user script error');nonExistingFunction();"); // works
context.run("setTimeout(function(){ console.log('Async user script error');nonExistingFunction(); },2000);"); // crash node process
}catch(err){
console.log("Recover sync user script error");
}
console.log("end test");
How can I catch async errors ?

I solved the problem by using child_process to create a thread for the script to execute in :
//main.js
var child_process = require('child_process');
var script = child_process.fork("scriptrunner.js");
script.on('error',function(err){
console.log("Thread module error " + JSON.stringify(err));
});
script.on('exit',function(code,signal){
if(code==null)
console.log("Script crashed");
else console.log("Script exited normally");
});
script.send("setTimeout(function(){ console.log('Async user script error');nonExistingFunction(); },2000);");
//scriptrunner.js
var contextify = require('contextify');
var context = {
console:{
log:function(msg){
console.log('Contextify : '+msg);
}
},
setTimeout:setTimeout
};
contextify(context);
process.on('message', function(js) {
try{
context.run(js);
}catch(err){
console.log("Catch sync user script error " + err);
}
});
So now if the script crashes it crash its own process and not the main node process. The downside is that I can't pass complex object (such as my context) between my main process and the script's thread, I need to find a workaround for that.

Related

Stop node server from another file

I have the following two files.
file1.js and file2.js
From file1.js, I start a node server that exists in files2.js by using Node exec from child process.
What I would like to do is, start the server that exists file2.js from file1.js by calling exec or spawn method from child_process. Stop it after 10s or so and restart the server again. How could I achieve this?
What I've tried is that, after I started the server, I called process.exit() and then tried to execute the exec function again, but since the process has exited, the second call to exec never actually reached.
I want to achieve this without using any external package though.
One way to do this is setTimeout():
const { exec } = require('child_process');
let stopped = false;
exec('command to start the server in file two', (err, stdout, stderr) => {
if (err) {
// handle error
} else {
// do stuff
}
});
setTimeout(function(){
exec('stop the server in file two', (err, stdout, stderr)=>{
stopped = true;
if(err){
// handle error
} else {
// do stuff
}
})
}, 10000);
if(stopped) {
exec('start server again', (err, stdout, stderr)=>{
stopped = false;
if(err){
// handle error
} else {
// do stuff
}
})
}

No password prompt returned to stdout when running script with nodejs' child_process.spwan(..)

I'm trying to create a utility that will squash flyway migrates. If I provide a password to the flyway conf file (so that no prompt is made), then the process runs as expected, however, in the case when a prompt for the flyway command should be generated (Which would consist of the text "Database password:"), then none is generated and a error for attempting to connect without a password is generated.
const child_process = require("child_process");
const os = require("os");
.
.
.
//Problem code below
let flywayMigrate = function(dbpassword){
return new Promise(function(){
let child = child_process.spawn(
"./flyway",
["migrate"],
{
cwd : "/home/admin/flyway"
}
);
child.stdout.on("data", function(data){
let out = data.toString();
console.log(out);
//containsString(haystack, needle) being a utility method
if(containsString(out, "Database password:")){
child.stdin.write(dbpassword);
child.stdin.write(os.EOL);
}
});
child.stderr.on("data",function(data){
console.log(data.toString());
reject();
});
child.on("exit", function(){
console.log("child process finished");
resolve();
});
});
}
Does anybody know what's up?

How to kill node.exe child process?

I have the following piece of code with the "npm start" argument starting a node server instance :
const childProcess = require("child_process");
// running server before tests
before(function(done) {
childProcess.exec(["npm start"], function(err, out, code) {
if (err instanceof Error)
throw err;
process.stderr.write(err);
process.stdout.write(out);
process.exit();
});
setTimeout(done, 5000);
});
//run tests
require("./customer-individual.js");
require("./customer-organization.js");
After tests run the node server instance is still running somewhere as a background process . How can i kill it ?
You can use the following:
const child = childProcess.exec(["npm start"], function(err, out, code) {
// ...
});
child.kill(); // same as child.kill('SIGTERM');
console.log(child.killed); // will log true
Or any other signal, please refer to the docs: https://nodejs.org/api/child_process.html#child_process_child_kill_signal

execute a node command from a grunt task

I have a grunt task from which I would like to run a node command. The command is not giving any error when I run it, but I was expecting some console output from the task, which I don't seem to be getting at all.
What am I missing in order to run this node task?
grunt.registerTask('asyncfoo', 'My "asyncfoo" task.', function() {
// Force task into async mode and grab a handle to the "done" function.
var done = this.async();
// Run some sync stuff.
grunt.log.writeln('Processing task...');
grunt.util.spawn({ cmd: 'node', args: ['S3ListBuckets.js']});
// And some async stuff.
setTimeout(function() {
grunt.log.writeln('All done!');
done();
}, 1000);
});
!-- if someone else is wanting to do something similar here is the code
module.exports = function(grunt) {
grunt.registerTask('asyncfoo', 'My "asyncfoo" task.', function() {
// Force task into async mode and grab a handle to the "done" function.
var done = this.async();
// Run some sync stuff.
grunt.log.writeln('Processing task...');
grunt.util.spawn({ cmd: 'node', args: ['S3ListBuckets.js'], opts: {stdio: 'inherit'}});
});
};
!-- list buckets
var fs = require('fs');
var aws = require('aws-sdk');
aws.config.loadFromPath('./grunt-aws.json');
var s3 = new aws.S3();
s3.listBuckets(function (err, data) {
if (err) {
console.log("Error:", err);
}
else {
for (var index in data.Buckets) {
var bucket = data.Buckets[index];
console.log("Bucket: ", bucket.Name, ' : ', bucket.CreationDate);
}
}
});
The answer https://stackoverflow.com/a/15045126/519995 suggests using the parameter opts: {stdio: 'inherit'} to have the spawned output streamed into the parent output stream.
That same answer also lists other alternatives: listening to data event, or piping the streams as you wish.
Also, using timeouts to wait for async tasks is NOT a good idea. If all you are waiting for is the spawned process you can use a callback to know when its done. If you have more complex sync I suggest starting a new StackOverflow question.

Node.js spawn child process and get terminal output live

I have a script that outputs 'hi', sleeps for a second, outputs 'hi', sleeps for 1 second, and so on and so forth. Now I thought I would be able to tackle this problem with this model.
var spawn = require('child_process').spawn,
temp = spawn('PATH TO SCRIPT WITH THE ABOVE BEHAVIOUR');
temp.stdout.pipe(process.stdout);
Now the problem is that the task needs to be finished in order for the output to be displayed. As I am understanding it, this is due to the fact that the newly spawned process takes execution control. Obviously node.js does not support threads so any solutions? My idea was to possibly run two instances, first one for the specific purpose of creating the task and have it pipe the output to process of the second instance, considering this can be achieved.
It's much easier now (6 years later)!
Spawn returns a childObject, which you can then listen for events with. The events are:
Class: ChildProcess
Event: 'error'
Event: 'exit'
Event: 'close'
Event: 'disconnect'
Event: 'message'
There are also a bunch of objects from childObject, they are:
Class: ChildProcess
child.stdin
child.stdout
child.stderr
child.stdio
child.pid
child.connected
child.kill([signal])
child.send(message[, sendHandle][, callback])
child.disconnect()
See more information here about childObject: https://nodejs.org/api/child_process.html
Asynchronous
If you want to run your process in the background while node is still able to continue to execute, use the asynchronous method. You can still choose to perform actions after your process completes, and when the process has any output (for example if you want to send a script's output to the client).
child_process.spawn(...); (Node v0.1.90)
var spawn = require('child_process').spawn;
var child = spawn('node ./commands/server.js');
// You can also use a variable to save the output
// for when the script closes later
var scriptOutput = "";
child.stdout.setEncoding('utf8');
child.stdout.on('data', function(data) {
//Here is where the output goes
console.log('stdout: ' + data);
data=data.toString();
scriptOutput+=data;
});
child.stderr.setEncoding('utf8');
child.stderr.on('data', function(data) {
//Here is where the error output goes
console.log('stderr: ' + data);
data=data.toString();
scriptOutput+=data;
});
child.on('close', function(code) {
//Here you can get the exit code of the script
console.log('closing code: ' + code);
console.log('Full output of script: ',scriptOutput);
});
Here's how you would use a callback + asynchronous method:
var child_process = require('child_process');
console.log("Node Version: ", process.version);
run_script("ls", ["-l", "/home"], function(output, exit_code) {
console.log("Process Finished.");
console.log('closing code: ' + exit_code);
console.log('Full output of script: ',output);
});
console.log ("Continuing to do node things while the process runs at the same time...");
// This function will output the lines from the script
// AS is runs, AND will return the full combined output
// as well as exit code when it's done (using the callback).
function run_script(command, args, callback) {
console.log("Starting Process.");
var child = child_process.spawn(command, args);
var scriptOutput = "";
child.stdout.setEncoding('utf8');
child.stdout.on('data', function(data) {
console.log('stdout: ' + data);
data=data.toString();
scriptOutput+=data;
});
child.stderr.setEncoding('utf8');
child.stderr.on('data', function(data) {
console.log('stderr: ' + data);
data=data.toString();
scriptOutput+=data;
});
child.on('close', function(code) {
callback(scriptOutput,code);
});
}
Using the method above, you can send every line of output from the script to the client (for example using Socket.io to send each line when you receive events on stdout or stderr).
Synchronous
If you want node to stop what it's doing and wait until the script completes, you can use the synchronous version:
child_process.spawnSync(...); (Node v0.11.12+)
Issues with this method:
If the script takes a while to complete, your server will hang for
that amount of time!
The stdout will only be returned once the script
has finished running. Because it's synchronous, it cannot continue
until the current line has finished. Therefore it's unable to capture
the 'stdout' event until the spawn line has finished.
How to use it:
var child_process = require('child_process');
var child = child_process.spawnSync("ls", ["-l", "/home"], { encoding : 'utf8' });
console.log("Process finished.");
if(child.error) {
console.log("ERROR: ",child.error);
}
console.log("stdout: ",child.stdout);
console.log("stderr: ",child.stderr);
console.log("exist code: ",child.status);
I'm still getting my feet wet with Node.js, but I have a few ideas. first, I believe you need to use execFile instead of spawn; execFile is for when you have the path to a script, whereas spawn is for executing a well-known command that Node.js can resolve against your system path.
1. Provide a callback to process the buffered output:
var child = require('child_process').execFile('path/to/script', [
'arg1', 'arg2', 'arg3',
], function(err, stdout, stderr) {
// Node.js will invoke this callback when process terminates.
console.log(stdout);
});
2. Add a listener to the child process' stdout stream (9thport.net)
var child = require('child_process').execFile('path/to/script', [
'arg1', 'arg2', 'arg3' ]);
// use event hooks to provide a callback to execute when data are available:
child.stdout.on('data', function(data) {
console.log(data.toString());
});
Further, there appear to be options whereby you can detach the spawned process from Node's controlling terminal, which would allow it to run asynchronously. I haven't tested this yet, but there are examples in the API docs that go something like this:
child = require('child_process').execFile('path/to/script', [
'arg1', 'arg2', 'arg3',
], {
// detachment and ignored stdin are the key here:
detached: true,
stdio: [ 'ignore', 1, 2 ]
});
// and unref() somehow disentangles the child's event loop from the parent's:
child.unref();
child.stdout.on('data', function(data) {
console.log(data.toString());
});
Here is the cleanest approach I've found:
require("child_process").spawn('bash', ['./script.sh'], {
cwd: process.cwd(),
detached: true,
stdio: "inherit"
});
I had a little trouble getting logging output from the "npm install" command when I spawned npm in a child process. The realtime logging of dependencies did not show in the parent console.
The simplest way to do what the original poster wants seems to be this (spawn npm on windows and log everything to parent console):
var args = ['install'];
var options = {
stdio: 'inherit' //feed all child process logging into parent process
};
var childProcess = spawn('npm.cmd', args, options);
childProcess.on('close', function(code) {
process.stdout.write('"npm install" finished with code ' + code + '\n');
});
PHP-like passthru
import { spawn } from 'child_process';
export default async function passthru(exe, args, options) {
return new Promise((resolve, reject) => {
const env = Object.create(process.env);
const child = spawn(exe, args, {
...options,
env: {
...env,
...options.env,
},
});
child.stdout.setEncoding('utf8');
child.stderr.setEncoding('utf8');
child.stdout.on('data', data => console.log(data));
child.stderr.on('data', data => console.log(data));
child.on('error', error => reject(error));
child.on('close', exitCode => {
console.log('Exit code:', exitCode);
resolve(exitCode);
});
});
}
Usage
const exitCode = await passthru('ls', ['-al'], { cwd: '/var/www/html' })
child:
setInterval(function() {
process.stdout.write("hi");
}, 1000); // or however else you want to run a timer
parent:
require('child_process').fork('./childfile.js');
// fork'd children use the parent's stdio
I found myself requiring this functionality often enough that I packaged it into a library called std-pour. It should let you execute a command and view the output in real time. To install simply:
npm install std-pour
Then it's simple enough to execute a command and see the output in realtime:
const { pour } = require('std-pour');
pour('ping', ['8.8.8.8', '-c', '4']).then(code => console.log(`Error Code: ${code}`));
It's promised based so you can chain multiple commands. It's even function signature-compatible with child_process.spawn so it should be a drop in replacement anywhere you're using it.
Adding a sample for exec as I too had needed live feedback and wasn't getting any until after the script finished. exec does return an EventEmitter, contrary to the many claims that only spawn works in such a way.
This supplements the comment I made to the accepted answer more thoroughly.
The interface for exec is similar to spawn:
// INCLUDES
import * as childProcess from 'child_process'; // ES6 Syntax
// DEFINES
let exec = childProcess.exec; // Use 'var' for more proper
// semantics, or 'const' it all
// if that's your thing; though 'let' is
// true-to-scope;
// Return an EventEmitter to work with, though
// you can also chain stdout too:
// (i.e. exec( ... ).stdout.on( ... ); )
let childProcess = exec
(
'./binary command -- --argument argumentValue',
( error, stdout, stderr ) =>
{ // When the process completes:
if( error )
{
console.log( `${error.name}: ${error.message}` );
console.log( `[STACK] ${error.stack}` );
}
console.log( stdout );
console.log( stderr );
callback(); // Gulp stuff
}
);
Now its as simple as registering an event handler for stdout:
childProcess.stdout.on( 'data', data => console.log( data ) );
And for stderr:
childProcess.stderr.on( 'data', data => console.log( `[ERROR]: ${data}` ) );
You can also pipe stdout to the main process' stdout:
childProcess.stdout.pipe( process.stdout );
Not too bad at all - HTH
I was interested into running a script that gets the input and outputs from my terminal, and that will close my process once the child script finishes.
import { spawn } from 'node:child_process'
import process from 'node:process'
const script = spawn('path/to/script', { stdio: 'inherit' })
script.on('close', process.exit)
I ran into a situation where none of the above worked when I was spawning a Python 3 script. I would get data from stdout, but only once the child terminated.
As it turns out, Python buffers stdout by default. It's possible to disable stdout buffering by including -u as a command line parameter to python3.

Resources