function execute(path, idx) {
if (idx == cmds.length) {
if (!self.keep) {
self.logger.info('Remove working directory: ' + self.path);
Tmp.cleanup();
} else {
self.logger.info('Keep working directory: ' + self.path);
}
return;
}
var fname = Path.join(path, 'task-' + pad(idx, 3));
Fs.writeFile(fname, cmds[idx], function (err) {
if (err) {
self.logger.error('File creation error: ' + err);
return;
}
self.logger.info('File created: ' + fname);
execFile(self.cmdshell, [ fname ], { cwd:path, env:process.env },
function (err, stdout, stderr) {
if (err) {
self.logger.error('Exec error: ' + err);
} else {
self.logger.info('Executed: ' + self.cmdshell + ' ' + fname);
process.stdout.write(stdout);
}
process.stderr.write(stderr);
execute(path, ++idx);
});
});
}
], function(err){
if(err) console.log(err);
temp.cleanup(function(err, stats) {
//console.log(stats);
if(err) console.log(err);
});
});
afterEach(done => { // cleanup after every test case
process.chdir(originalCwd) // set back to old current workdir
temp.cleanup((err, stats) => {
// do something
return done()
})
})
return new Promise(function(resolve, reject){
temp.cleanup(function(err, result){
if(err){
return reject(err);
}
resolve(result);
});
});
function(err, response) {
node.status({});
if (err) {
node.error(err);
} else {
node.send({'payload' : response});
}
temp.cleanup();
}
return new Promise((resolve, reject) => {
temp.cleanup((err, stats) => {
resolve();
if (err && err.message !== 'not tracking') {
// eslint-disable-next-line no-console
console.log('temp.cleanup() failed.', err);
}
});
});
.then(() => {
temp.cleanup();
if (config['streaming-mode']) {
node.status({fill:'blue', shape:'dot', text:'listening for socket data'});
} else {
node.status({});
node.send(msg);
}
})
setInterval(function () {
if (compilerEnv.isBusy()) {
logger.warn("Skipping temporary file clean up as compiler environment is busy");
return;
}
temp.cleanup(function (err, stats) {
if (err) logger.error("Error cleaning directories: ", err);
if (stats) logger.debug("Directory cleanup stats:", stats);
});
}, tempDirCleanupSecs * 1000);
await new Promise(resolve => {
// Atom intercepts "process.exit" so we have to do our own manual cleanup.
const temp = require('temp');
temp.cleanup((err, stats) => {
resolve();
if (err && err.message !== 'not tracking') {
// eslint-disable-next-line no-console
console.log(`temp.cleanup() failed. ${err}`);
}
});
});
.catch(function(err) {
payloadutils.reportError(node, msg, err);
msg.result = {};
msg.result['error'] = err;
// Note: This node.send forwards the error to the next node,
// if this isn't desired then this line needs to be removed.
// Should be ok as the node.error would already have recorded
// the error in the debug console.
temp.cleanup();
node.send(msg);
});
await new Promise(resolve => {
const temp = require('temp');
if (statusCode === 0) {
// Atom intercepts "process.exit" so we have to do our own manual cleanup.
temp.cleanup((err, stats) => {
resolve();
if (err && err.message !== 'not tracking') {
// eslint-disable-next-line no-console
console.log(`temp.cleanup() failed. ${err}`);
}
});
} else {
// When the test fails, we keep the temp contents for debugging.
temp.track(false);
resolve();
}
});
node.on('input', function (msg) {
var params = {};
node.status({});
// so there is at most 1 temp file at a time (did not found a better solution...)
temp.cleanup();
b = verifyPayload(node, msg);
if (!b) {
return;
}
b = verifyInputs(node, msg);
if (!b) {
return;
}
b = verifyServiceCredentials(node, msg);
if (!b) {
return;
}
execute(feature,params,node,msg);
});
setTimeout(function() {
var src;
try {
src = fs.readFileSync(outFile, 'utf-8');
} catch (e) {
t.fail('Failed to open dest file: ' + outFile);
}
t.match(src, mendelRequireRegexp);
t.notMatch(src, requireRegexp);
var wrapper = requireTransform.wrapper;
t.equal(src.indexOf(wrapper[0]), 0, 'wrapper prelude pos');
t.equal(src.indexOf(wrapper[1]), src.length - wrapper[1].length, 'wrapper epilogue pos');
temp.cleanup(function() {
if (cb) {
return cb(t);
}
t.end();
});
}, 150);
fs.writeFile(info.path, msg.payload, function(err) {
if (err) {
node.status({
fill: 'red',
shape: 'dot',
text: 'Error processing data buffer for training'
});
throw err;
}
switch (method) {
case 'addWords':
try {
params.words = JSON.parse(fs.readFileSync(info.path, 'utf8'));
} catch (err) {
params.words = fs.createReadStream(info.path);
}
}
executeMethod(node, method, params, msg);
temp.cleanup();
});
], function (err) {
if (err) {
log.send(deployment_id, 'error', 'repository.package-failed', {
"error": err
});
} else {
log.send(deployment_id, 'info', 'repository.package-success', {
"version_label": version
});
}
debug("application publication status: %s", err ? "failed" : "success");
temp.cleanup(function () {
if (err) {
cache.put("application-package-status:" + deployment_id, "error", 10 * 60 * 1000);
} else {
cache.del("application-package-status:" + deployment_id);
}
cache.del("creating-application-package");
callback && callback(err, version);
});
});
after(function () {
temp.cleanup();
});
app.post(`${exports.pathPrefix}/testing/cleanup`, ensureAuthenticated, (req, res) => {
//winston.info('Cleaned up: ' + JSON.stringify(cleaned));
res.json({ result: temp.cleanup() });
});
agent.close(function () {
temp.cleanup(function () {
t.end();
});
});
afterEach(done => {
temp.cleanup(done);
});
function periodicCleanup() {
temp.cleanup(function (err, stats) {
if (err) console.log("Error cleaning directories: ", err);
if (stats) console.log("Directory cleanup stats:", stats);
});
}
.catch((err) => {
temp.cleanup();
payloadutils.reportError(node,msg,err);
});
test('teardown', function (t) {
temp.cleanup(function () {
t.end();
});
});
afterEach(function () {
temp.cleanup();
});
.then(function(){
temp.cleanup();
node.status({});
node.send(msg);
})
app.post(exports.pathPrefix + '/testing/cleanup', ensureAuthenticated, function(req, res){
temp.cleanup();
res.json({ });
});
.catch(function(err){
temp.cleanup();
payloadutils.reportError(node,msg,err);
node.send(msg);
});
app.post(exports.pathPrefix + '/testing/cleanup', ensureAuthenticated, function(req, res){
var cleaned = temp.cleanup();
//winston.info('Cleaned up: ' + JSON.stringify(cleaned));
res.json({ result: cleaned });
});
.then(data => {
temp.cleanup()
return data.Key
})
}).on('complete',function(body,res){
expect(res.statusCode).to.equal(200)
expect(body.status).to.equal('ok')
temp.cleanup()
done()
})
zipStream.finalize(function(bytesZipped) {
console.log(bytesZipped + ' bytes zippped.');
temp.cleanup();
});