data.forEach(function(instance){
forever.startDaemon(instance.filename, {'sourceDir': instance.sourceDir, 'watch': instance.watch, 'cwd': instance.cwd, 'uid':instance.unitname})
/*.on('error',function(a,b,c){
console.log('forever Error A :::', a);
console.log('forever Error B :::', b);
console.log('forever Error C :::', c);
})*/;
});
function startDaemon(path) {
console.log('Starting daemon: ' + path);
forever.startDaemon(path, {
max: 3,
silent: false,
args: args
});
}
function start() {
// see https://github.com/nodejitsu/forever-monitor for options
forever.startDaemon('server.js', {
sourceDir: __dirname,
cwd: process.cwd(),
uid: 'monploy-agent'
});
}
function launch() {
forever.startDaemon('index.js', {
'uid': 'fbash',
'script': 'index.js',
'sourceDir': __dirname,
'logFile': path.join(fbashDir, 'forever.log'),
'outFile': path.join(fbashDir, 'out.log'),
'errFile': path.join(fbashDir, 'err.log')
});
console.log('Started fbash.');
}
function startForever(done) {
let config = mergeEnvironment();
forever.startDaemon('./build/core/server/app/server.js', config.serve.forever);
console.log(chalk.yellow.bold('ModernMean Production server running as Forever Daemon'));
console.log(chalk.yellow.bold('You can now use any forever command line options'));
console.log(chalk.yellow.bold('https://github.com/foreverjs/forever'));
return done();
}
getServer(function (data) {
if (data) {
console.log('Crypton already running');
process.exit(1);
}
var monitor = forever.startDaemon(__filename, {
options: [ 'run' ]
});
console.log('Crypton server started');
});
exports.startDS = function (callback) {
forever.startDaemon(ds, {
silent: true,
cwd: ds,
env: { NAME: 'data-system', TOKEN: 'token' },
isCorbuDS: true,
logFile: logFile,
outFile: resolve(logs, 'forever-ds-stdout.log'),
errFile: resolve(logs, 'forever-ds-stderr.log'),
});
setTimeout(callback, 5000); // let DS start
};
caddis.start = function(port, callback) {
mkdirp.sync(tmp);
if(fs.existsSync(caddis.outlog)) {
fs.writeFileSync(caddis.outlog, '', 'utf8');
}
generateServerScript(port, caddis.original, caddis.server);
forever.startDaemon(caddis.server, {
logFile: caddis.outlog,
append: false
})
.on('error', function(error) {
callback(error);
});
checkRegistry(caddis.server, callback);
};
var launch = function () {
if (!program.stop) {
var app_dir = path.dirname(require.main.filename);
var script = 'start-broker.js';
var options = {
silent: !program.verbose,
uid: 'dts-as-broker',
sourceDir: app_dir,
logFile: '/dev/null',
outFile: '/dev/null',
errFile: '/dev/null',
};
if (program.daemon) {
forever.startDaemon(script, options);
} else {
forever.start(script, options);
}
}
}
findProcessWithIndex( index, function(process) {
// if found, be on our way without failing.
if( typeof process !== 'undefined' ) {
warn( index + ' is already running.');
log( forever.format(true, [process]) );
done();
}
else {
gruntRef.file.mkdir(logDir);
// 'forever start -o out.log -e err.log -c node -a -m 3 index.js';
forever.startDaemon( index, {
errFile: errFile,
outFile: logFile,
command: commandName,
append: true,
max: Math.Infinity
});
log( 'Logs can be found at ' + logDir + '.' );
done();
}
});
exports.start = function (options) {
if (options.daemon) {
delete options.daemon;
var forever = require('forever');
var args = Object.keys(options).map(function (key) {
var arg = '--' + key;
if (typeof options[key] !== 'boolean') {
arg += '=' + options[key];
}
return arg;
});
forever.startDaemon('start', {
command: 'gspadmin',
options: args,
logFile: options.base + '/log.txt'
});
}
else {
start(options);
}
};
var start = function () {
var deferred = Q.defer();
var daemonRootDir = path.resolve(__dirname, '../daemon'),
binPath = path.join(daemonRootDir, 'mockify.js');
forever.startDaemon(binPath, {
silent : false,
max : 10,
watch : true,
watchDirectory : daemonRootDir,
cwd : daemonRootDir,
logFile : path.join(daemonRootDir, 'log', 'mockify.log'),
outFile : path.join(daemonRootDir, 'log', 'mockify.out.log'),
errFile : path.join(daemonRootDir, 'log', 'mockify.err.log')
});
// @FIXME Handle forever errors
deferred.resolve('mockify daemon has been started.');
return deferred.promise;
};
conf.createMockifyDir(function (err, mockifyDir) {
if (err) {
deferred.reject(err);
return;
}
var daemonRootDir = path.resolve(__dirname, '..', 'daemon'),
daemonFile = path.join(daemonRootDir, 'mockify.js');
forever.startDaemon(daemonFile, {
silent : false,
max : 10,
watch : true,
watchDirectory : daemonRootDir,
cwd : daemonRootDir,
logFile : path.join(mockifyDir, 'mockify.log'),
outFile : path.join(mockifyDir, 'mockify.out.log'),
errFile : path.join(mockifyDir, 'mockify.err.log')
});
// @FIXME Handle forever errors
deferred.resolve('mockify daemon has been started.');
});
findProcessWithIndex( index, function(process) {
// if found, be on our way without failing.
if( typeof process !== 'undefined' ) {
warn( index + ' is already running.');
log( forever.format(true, [process]) );
done();
}
else {
gruntRef.file.mkdir(logDir);
// 'forever start -o out.log -e err.log -c node -a -m 3 index.js';
config = {
command: commandName,
append: true,
max: 3,
killSignal: killSignal
};
appendConfig('errFile', errFile);
appendConfig('outFile', outFile);
appendConfig('logFile', logFile);
forever.startDaemon( index, config );
log( 'Logs can be found at ' + logDir + '.' );
done();
}
});
* Validate args
*/
if (program.args.length === 0) {
console.error('Arguments needed, use --help');
process.exit();
} else {
var files = program.args;
}
if (program.daemonize) {
forever.startDaemon(__filename, {
'silent': false,
'max': 3,
'pidFile': program.pidPath,
'outFile': program.logPath,
'options': [
'-p', program.port,
'-n', program.number,
files
]
});
} else {
/**
* Server setup
*/
var app = connect()
.use(connect.static(__dirname + '/assets'))
.use(function (req, res) {
fs.readFile(__dirname + '/index.html', function (err, data) {
if (err) {
res.writeHead(500, {'Content-Type': 'text/plain'});
else {
var globalSailsPath = __dirname + '/../';
require('sails').lift();
// sails.log.verbose("Installing Sails in this project...");
// fs.mkdirsSync(localSailsPath);
// fs.copy(globalSailsPath, localSailsPath, function(err) {
// if(err) throw new Error(err);
// });
}
}
// Daemonize server
else if(argv.d || argv._[0] && _.contains(['forever'], argv._[0])) {
var forever = require('forever');
forever.startServer();
forever.startDaemon('sails lift');
// Create temporary app file
// fs.writeFileSync(sails.config.appPath + '/.app.js', function (){});
// copy down global install of sails locally if one doesn't already exist
// if(!fs.existsSync(sails.config.appPath + '/node_modules/sails')) {}
// run file
}
// Stop all servers
else if(argv._[0] && _.contains(['stop', 'kill'], argv._[0])) {
}
// Start this app in interactive mode
else if(_.contains(['console'], argv._[0])) {
sails.log.ship();
#!/usr/bin/env node
var forever = require('forever');
var wd = __dirname + '/..';
var config = require('../config.js');
var child = forever.startDaemon(
'/bin/cron.js',
{
silent : false,
sourceDir : wd,
cwd : wd,
logFile : wd + config.logFile,
outFile : wd + config.outFile,
errFile : wd + config.errFile
}
);
child.on('start', function(process) {
console.log('hi');
forever.startServer(child);
});
child.on('exit', function(forever) {
console.log('exit');
});
child.on('error', function(err) {
console.log('error: '+ JSON.stringify(err));
});
.action(function() {
forever.startDaemon(SERVER_PATH);
});
isProcessRunning(uid, function(running) {
if (!running) {
var r = forever.startDaemon(p.cmd, p.options);
forever.startServer(r);
}
});
/*
* Rhapsody Control
* Version 1.0
* Chris Davison
*/
// Create forever instance
var forever = require('forever'),
options = {
'uid': 'rhapsody-control',
'logFile': 'rhapsody-control.log',
'outFile': 'rhapsody-control_out.log',
'errFile': 'rhapsody-control_err.log'
},
monitor = forever.startDaemon('js/server.min.js', options);
forever.startDaemon(
'appMulti.js',
{
silent: true,
pidFile: '/tmp/terminii.pid',
cwd: oCwd,
watch: true,
watchDirectory: oCwd,
watchIgnorePatterns: [
oCwd + 'bin',
oCwd + 'bin/**',
oCwd + 'bootstrap',
oCwd + 'bootstrap/**',
oCwd + 'test',
oCwd + 'test/**',
oCwd + '.git',
oCwd + '.git/**',
oCwd + '.gitignore',
oCwd + 'npm-debug.log'
],
logFile: '/tmp/terminii.log',
outFile: '/tmp/terminii.out',
errFile: '/tmp/terminii.err',
env: {
},
options: []
}
);
'use strict';
var fs = require('fs');
var path = require('path');
var forever = require('forever');
var utils = require('./lib/utils.module.js').init();
process.env.NODE_ENV = 'production';
var logsPath = 'files/logs/';
var logsFullPath = path.join(__dirname, logsPath);
if(!fs.existsSync(logsFullPath))
utils.mkdirRecursive(logsFullPath);
forever.startDaemon(path.join(__dirname, 'dev.js'), {
silent: true,
uid: 'master',
cwd: path.join(__dirname),
pidFile: 'subkit.pid',
append: true,
logFile: path.join(logsFullPath, 'proc.log.txt'),
outFile: path.join(logsFullPath, 'out.log.txt'),
errFile: path.join(logsFullPath, 'err.log.txt')
});