blue = function (str) {
return colors[color] + str + reset;
}n/a
bright_blue = function (str) {
return colors[color] + str + reset;
}n/a
bright_cyan = function (str) {
return colors[color] + str + reset;
}n/a
bright_green = function (str) {
return colors[color] + str + reset;
}n/a
bright_magenta = function (str) {
return colors[color] + str + reset;
}n/a
bright_red = function (str) {
return colors[color] + str + reset;
}...
};
this.Warn = function Warn() {
logger.warn(colors.yellow('[WARN] ' + this.fmt.apply(null, arguments)));
};
this.Error = function Error() {
logger.error(colors.bright_red('[FAIL] ' + this.fmt.apply(null,arguments
)));
};
}
module.exports = Console;
Console.Console = new Console();
...bright_yellow = function (str) {
return colors[color] + str + reset;
}...
return ppath.resolve(__dirname, type, file);
}
}
function writeout(path) {
return function(data) {
if (fs.existsSync(path)) {
display.Warn(colors.bright_yellow('Replacing: %s'), path);
}
fs.writeFileSync(path,data);
display.Alert('Wrote :',ppath.normalize(path));
};
}
...cyan = function (str) {
return colors[color] + str + reset;
}...
writeout.foreman(config,command.out);
});
program.parse(process.argv);
if (!process.argv.slice(2).length) {
console.log(colors.cyan(' _____ '));
console.log(colors.cyan(' | __|___ ___ ___ _____ ___ ___ '));
console.log(colors.yellow(' | __| . | _| -_| | | |'));
console.log(colors.magenta(' |__| |___|_| |___|_|_|_|_^_|_|_|'));
program.outputHelp();
process.exit(1);
}
...green = function (str) {
return colors[color] + str + reset;
}...
});
};
// Foreman Loggers //
this.Alert = function Alert() {
logger.log(colors.green('[OKAY] '+ this.fmt.apply(null, arguments)));
};
this.Done = function Info() {
logger.log(colors.cyan('[DONE] ' + this.fmt.apply(null, arguments)));
};
this.Warn = function Warn() {
...magenta = function (str) {
return colors[color] + str + reset;
}...
program.parse(process.argv);
if (!process.argv.slice(2).length) {
console.log(colors.cyan(' _____ '));
console.log(colors.cyan(' | __|___ ___ ___ _____ ___ ___ '));
console.log(colors.yellow(' | __| . | _| -_| | | |'));
console.log(colors.magenta(' |__| |___|_| |___|_|_|_|_^_|_|_|'));
program.outputHelp();
process.exit(1);
}
...red = function (str) {
return colors[color] + str + reset;
}...
this.info = function info(key, proc, string) {
var stamp = (new Date().toLocaleTimeString()) + " " + key;
logger.log(proc.color(this.pad(stamp,this.padding)), colors.cyan(string));
};
this.error = function error(key, proc, string) {
var stamp = (new Date().toLocaleTimeString()) + " " + key;
logger.error(proc.color(this.pad(stamp,this.padding)), colors.red(string));
};
this.log = function log(key, proc, string) {
var self = this;
if(self.raw) {
logger.log(string);
...yellow = function (str) {
return colors[color] + str + reset;
}...
});
program.parse(process.argv);
if (!process.argv.slice(2).length) {
console.log(colors.cyan(' _____ '));
console.log(colors.cyan(' | __|___ ___ ___ _____ ___ ___ '));
console.log(colors.yellow(' | __| . | _| -_| | | |'));
console.log(colors.magenta(' |__| |___|_| |___|_|_|_|_^_|_|_|'));
program.outputHelp();
process.exit(1);
}
...function dumpEnv(conf) {
var output = [];
for (var key in conf) {
output.push(key + '=' + conf[key]);
}
return output.sort().join('\n') + '\n';
}n/a
function flattenJSON(json) {
var flattened = {};
walk(json, function(path, item) {
flattened[path.join('_').toUpperCase()] = item;
});
return flattened;
function walk(obj, visitor, path) {
var item;
path = path || [];
for (var key in obj) {
item = obj[key];
if (typeof item === 'object') {
walk(item, visitor, path.concat(key));
} else {
visitor(path.concat(key), item);
}
}
}
}n/a
function keyValue(data) {
var env = {};
data
.toString()
.replace(/^\s*\#.*$/gm,'')
.replace(/^\s*$/gm,'')
.split(/\n/)
.map(method('trim'))
.filter(notBlank)
.forEach(capturePair);
return env;
function notBlank(str) {
return str.length > 2;
}
function capturePair(line) {
var pair = line.split('=');
var key = pair[0].trim();
var rawVal = pair.slice(1).join('=').trim();
env[key] = parseValue(rawVal);
}
function parseValue(val) {
switch (val[0]) {
case '"': return /^"([^"]*)"/.exec(val)[1];
case "'": return /^'([^']*)'/.exec(val)[1];
default : return val.replace(/\s*\#.*$/, '');
}
}
}n/a
function loadEnvs(path) {
var envs = path.split(',').map(loadEnvsFile).reduce(util._extend, {});
var sorted = Object.create(null);
Object.keys(envs).sort().forEach(function(k) {
sorted[k] = envs[k];
});
return sorted;
}n/a
function once(input, envs, callback) {
var file, args;
var proc = {
command : input,
env : merge(merge({}, process.env), envs)
};
if (platform === 'win32') {
file = process.env.comspec || 'cmd.exe';
args = ['/s', '/c', proc.command];
} else {
file = '/bin/sh';
args = ['-c', proc.command];
}
var child = prog.spawn(file, args, { env: proc.env, stdio: 'inherit' });
child.on('close', function(code) {
callback(code);
});
}...
program.option('-e, --env <FILE>' ,'load environment from FILE, a comma-separated list','
;.env');
program.option('-p, --port <PORT>' ,'start indexing ports at number PORT',0);
// Foreman Event Bus/Emitter //
var emitter = new events.EventEmitter();
emitter.once('killall',function(signal){
display.Done("Killing all processes with signal ", signal);
});
emitter.setMaxListeners(50);
var _proc = require('./lib/proc');
var start = _proc.start;
var once = _proc.once;
...function run(key, proc, emitter) {
var file, args;
if (platform === 'win32') {
file = process.env.comspec || 'cmd.exe';
args = ['/s', '/c', proc.command];
} else {
file = '/bin/sh';
args = ['-c', proc.command];
}
var child = prog.spawn(file, args, { env: proc.env });
child.stdout.on('data', function(data) {
cons.log(key, proc, data.toString());
});
child.stderr.on('data', function(data) {
cons.log(key, proc, data.toString());
});
child.on('close', function(code) {
if(code === 0) {
cons.info(key, proc, "Exited Successfully");
} else {
cons.error(key, proc, "Exited with exit code " + code);
}
});
child.on('exit', function(code, signal) {
emitter.emit('killall', signal);
});
emitter.on('killall', function(signal) {
child.kill(signal);
});
}n/a
function start(procs, requirements, envs, portarg, emitter){
var j = 0;
var k = 0;
var port = parseInt(portarg);
if(port < 1024) {
return cons.Error('Only Proxies Can Bind to Privileged Ports - '+
'Try \'sudo nf start -x %s\'', port);
}
for(var key in requirements) {
var n = parseInt(requirements[key]);
for(var i = 0; i < n; i++) {
var color_val = (j + k) % colors_max;
if (!procs[key]) {
cons.Warn("Required Key '%s' Does Not Exist in Procfile Definition", key);
continue;
}
var p = {
command : procs[key],
color : colors[color_val],
env : merge(merge({}, process.env), envs)
};
p.env.PORT = port + j + k * 100;
p.env.FOREMAN_WORKER_NAME = p.env.FOREMAN_WORKER_NAME || key + "." + (i + 1);
run(key + "." + (i + 1), p, emitter);
j++;
}
j = 0;
k++;
}
}n/a
function loadProc(filename) {
try {
var data = fs.readFileSync(filename);
return procs(data);
} catch(e) {
cons.Warn(e.message);
if(fs.existsSync('package.json')) {
cons.Alert("package.json file found - trying 'npm start'");
return procs("web: npm start");
} else {
cons.Error("No Procfile and no package.json file found in Current Directory - See " + path.basename(process.argv[1]) + " --
help");
return;
}
}
}n/a
function procs(procdata){
var processes = {};
procdata.toString().split(/\n/).forEach(function(line) {
if(!line || line[0] === '#') { return; }
var tuple = /^([A-Za-z0-9_-]+):\s*(.+)$/m.exec(line);
var prockey = tuple[1].trim();
var command = tuple[2].trim();
if(!prockey) {
throw new Error('Syntax Error in Procfile, Line %d: No Prockey Found');
}
if(!command) {
throw new Error('Syntax Error in Procfile, Line %d: No Command Found');
}
processes[prockey] = command;
});
return processes;
}n/a
function calculatePadding(reqs) {
var padding = 0;
for(var key in reqs){
var num = reqs[key];
var len = key.length + num.toString().length;
if(len > padding) {
padding = len;
}
}
return padding + 12;
}n/a
function getreqs(args, proc) {
var req;
if(args && args.length > 0) {
// Run Specific Procs
req = parseRequirements(args);
} else {
// All
req = {};
for(var key in proc){
req[key] = 1;
}
}
return req;
}n/a