pm.process_metrics(metrics_hash, flushInterval, time_stamp, function emitFlush(metrics) {
backendEvents.emit('flush', time_stamp, metrics);
});
#!/usr/bin/env node
var EventEmitter = require('events').EventEmitter;
var emitter = new EventEmitter();
emitter.on('foo', function() {
console.log('on foo');
});
var emitter2 = new EventEmitter();
emitter2.emit('foo'); // Not emitted
var connectHandler = function connected() {
console.log('连接成功。');
// 触发 data_received 事件
eventEmitter.emit('data_received');
}
var http = require('http');
var url = require('url');
var fs = require('fs');
var events = require('events');
var eventEmitter = new events.EventEmitter();
var myEventHandler = function () {
console.log('I hear a scream!');
}
eventEmitter.on('scream', myEventHandler);
eventEmitter.emit('scream');
var events = require('events');
var emitter = new events.EventEmitter();
emitter.on('someEvent', function(arg1, arg2) {
console.log('listener1', arg1, arg2);
});
emitter.on('someEvent', function(arg1, arg2) {
console.log('listener2', arg1, arg2);
});
emitter.emit('someEvent', 'byvoid', 1991);
ftpCommand('PASS ' + service.password, function(data) {
service.status = "up";
service.statusCode = 0;
service.message = "";
controller.emit(service.status, service);
});
.on('error', function(e) {
service.status = "down";
service.statusCode = 0;
service.message = e.message;
controller.emit(service.status, service);
});
return function(doc, options, done) {
HouseTypeEvents.emit(event + ':' + doc._id, doc);
HouseTypeEvents.emit(event, doc);
done(null);
}
e5.removeListener('hello', listener1);
assert.deepStrictEqual([], e5.listeners('hello'));
const e6 = new events.EventEmitter();
const listener3 = common.mustCall(() => {
e6.removeListener('hello', listener4);
}, 2);
const listener4 = common.mustCall(() => {}, 1);
e6.on('hello', listener3);
e6.on('hello', listener4);
// listener4 will still be called although it is removed by listener 3.
e6.emit('hello');
// This is so because the interal listener array at time of emit
// was [listener3,listener4]
// Interal listener array [listener3]
e6.emit('hello');
const e7 = new events.EventEmitter();
const listener5 = () => {};
e7.once('hello', listener5);
e7.on('removeListener', common.mustCall((eventName, listener) => {
assert.strictEqual(eventName, 'hello');
assert.strictEqual(listener, listener5);
}));
function emitHungryAnimalEvents()
{
hungryAnimalEventEmitter.emit("HungryCat");
hungryAnimalEventEmitter.emit("HungryDog");
hungryAnimalEventEmitter.emit("Fed");
}
youtubedl.stderr.on('data', function(data) {
data = data.toString().trim();
var err = new Error(data.substring(7, data.length - 1));
emitter.emit('error', err);
});
const eventEmitter = new events.EventEmitter()
// Criamos as funções que serão chamadas quando o evento acontecer
var correrParaOBanheiro = () =>{
console.log('correndo para o banheiro...');
};
var cagar = () =>{
console.log('cagando...');
};
var pegarPapelHigienico = () =>{
console.log('pegando o papele higienico com calma e cuidado...');
};
var limparABunda = () =>{
console.log('limpando o orifício anal para ficar macio e sedoso...');
};
var passarBomAr = () =>{
console.log('passando Bom Ar para mascarar o fedor de gambá apodrecendo...');
};
// Ligamos o evento vontadeDeCagar com as funções
eventEmitter.on('vontadeDeCagar', correrParaOBanheiro);
eventEmitter.on('vontadeDeCagar', cagar);
eventEmitter.on('vontadeDeCagar', pegarPapelHigienico);
eventEmitter.on('vontadeDeCagar', limparABunda);
eventEmitter.on('vontadeDeCagar', passarBomAr);
eventEmitter.emit('vontadeDeCagar');
stream.on('data', function(data) {
var cmdline = data.trim().split(" ");
var cmd = cmdline.shift();
switch(cmd) {
case "help":
stream.write("Commands: stats, counters, timers, gauges, delcounters, deltimers, delgauges, quit\n\n");
break;
case "stats":
var now = Math.round(new Date().getTime() / 1000);
var uptime = now - startup_time;
stream.write("uptime: " + uptime + "\n");
var stat_writer = function(group, metric, val) {
var delta;
if (metric.match("^last_")) {
delta = now - val;
}
else {
delta = val;
}
stream.write(group + "." + metric + ": " + delta + "\n");
};
// Loop through the base stats
for (var group in stats) {
for (var metric in stats[group]) {
stat_writer(group, metric, stats[group][metric]);
}
}
backendEvents.once('status', function(writeCb) {
stream.write("END\n\n");
});
// Let each backend contribute its status
backendEvents.emit('status', function(err, name, stat, val) {
if (err) {
l.log("Failed to read stats for backend " +
name + ": " + err);
} else {
stat_writer(name, stat, val);
}
});
break;
case "counters":
stream.write(util.inspect(counters) + "\n");
stream.write("END\n\n");
break;
case "timers":
stream.write(util.inspect(timers) + "\n");
stream.write("END\n\n");
break;
case "gauges":
stream.write(util.inspect(gauges) + "\n");
stream.write("END\n\n");
break;
case "delcounters":
for (var counter_index in cmdline) {
delete counters[cmdline[counter_index]];
stream.write("deleted: " + cmdline[counter_index] + "\n");
}
stream.write("END\n\n");
break;
case "deltimers":
for (var timer_index in cmdline) {
delete timers[cmdline[timer_index]];
stream.write("deleted: " + cmdline[timer_index] + "\n");
}
stream.write("END\n\n");
break;
case "delgauges":
for (var gauge_index in cmdline) {
delete gauges[cmdline[gauge_index]];
stream.write("deleted: " + cmdline[gauge_index] + "\n");
}
stream.write("END\n\n");
break;
case "quit":
stream.end();
break;
default:
stream.write("ERROR\n");
break;
}
});
server = dgram.createSocket(udp_version, function (msg, rinfo) {
backendEvents.emit('packet', msg, rinfo);
counters[packets_received]++;
var packet_data = msg.toString();
if (packet_data.indexOf("\n") > -1) {
var metrics = packet_data.split("\n");
} else {
var metrics = [ packet_data ] ;
}
for (var midx in metrics) {
if (config.dumpMessages) {
l.log(metrics[midx].toString());
}
var bits = metrics[midx].toString().split(':');
var key = bits.shift()
.replace(/\s+/g, '_')
.replace(/\//g, '-')
.replace(/[^a-zA-Z_\-0-9\.]/g, '');
if (keyFlushInterval > 0) {
if (! keyCounter[key]) {
keyCounter[key] = 0;
}
keyCounter[key] += 1;
}
if (bits.length === 0) {
bits.push("1");
}
for (var i = 0; i < bits.length; i++) {
var sampleRate = 1;
var fields = bits[i].split("|");
if (fields[2]) {
if (fields[2].match(/^@([\d\.]+)/)) {
sampleRate = Number(fields[2].match(/^@([\d\.]+)/)[1]);
} else {
l.log('Bad line: ' + fields + ' in msg "' + metrics[midx] +'"; has invalid sample rate');
counters[bad_lines_seen]++;
stats.messages.bad_lines_seen++;
continue;
}
}
if (fields[1] === undefined) {
l.log('Bad line: ' + fields + ' in msg "' + metrics[midx] +'"');
counters[bad_lines_seen]++;
stats.messages.bad_lines_seen++;
continue;
}
var metric_type = fields[1].trim();
if (metric_type === "ms") {
if (! timers[key]) {
timers[key] = [];
timer_counters[key] = 0;
}
timers[key].push(Number(fields[0] || 0));
timer_counters[key] += (1 / sampleRate);
} else if (metric_type === "g") {
if (gauges[key] && fields[0].match(/^[-+]/)) {
gauges[key] += Number(fields[0] || 0);
} else {
gauges[key] = Number(fields[0] || 0);
}
} else if (metric_type === "s") {
if (! sets[key]) {
sets[key] = new set.Set();
}
sets[key].insert(fields[0] || '0');
} else {
if (! counters[key]) {
counters[key] = 0;
}
counters[key] += Number(fields[0] || 1) * (1 / sampleRate);
}
}
}
stats.messages.last_msg_seen = Math.round(new Date().getTime() / 1000);
});
function online(worker) {
worker.state = 'online';
worker.emit('online');
cluster.emit('online', worker);
}
channel.on('leave', function(id) {
channel.removeListener('broadcast', this.subscriptions[id]);
channel.emit('broadcast', id, id + " has left the chat.\n");
});
stream.addListener('error', function (e) {
service.status = "down";
service.statusCode = e.errno;
service.message = e.message;
controller.emit(service.status, service);
});
channel.on('shutdown', function() {
channel.emit('broadcast', '', "Chat has shut down.\n");
channel.removeAllListeners('broadcast');
});
var ftpError = function(status, message) {
service.status = "down";
service.statusCode = status;
service.message = message;
controller.emit(service.status, service);
};
client.on('close', function() {
channel.emit('leave', id);
});
stream.on('error', function(err){
em.emit('error', err);
});
return function(doc) {
WordPackEvents.emit(event + ':' + doc._id, doc);
WordPackEvents.emit(event, doc);
}
event.save(function() {
me.emit('eventChanged');
me.findOrCreateNextEvent(next);
});
exports.create = function(name, props) {
// Retrieve schema definition from file if any....
var schemaDef = schemas[name] || {options: {}},
_virtuals = {};
props = props || { };
extend(props, schemaDef);
// Check for a scheme definition
if (props.schema) {
// Look for circular references
Object.keys(props.schema).forEach(function(key) {
var def = props.schema[key];
if (typeof def === 'object' && def.type === oid) {
// Shortcut simple circular reference to self
if (def.ref === '$circular') {
def.ref = { $circular: name };
}
// Handle circular references
if (typeof def.ref === 'object' && def.ref && def.ref.$circular) {
var model = def.ref.$circular;
// First, check if the model is already loaded
if (models[model] && typeof models[model] === 'object') {
props.schema[key].ref = models[model].schema;
}
// Otherwise, wait and resolve it later
else {
circles.once(model, function(model) {
def.ref = model.schema;
var update = { };
update[key] = def;
props.schema.add(update);
});
delete props.schema[key];
}
}
}
// Handle automatic virtuals for custom types
var type = def;
if (typeof def === 'object') {
type = def.type;
}
if (typeof type === 'function' && type._mmId) {
var funcs = virtuals[type._mmId](key);
Object.keys(funcs).forEach(function(virtual) {
if (virtual[0] === '.') {
virtual = key + virtual;
}
_virtuals[virtual] = funcs[virtual];
});
}
});
// Create the schema
props.schema = new mongoose.Schema(props.schema);
// Bind automatic virtuals
Object.keys(_virtuals).forEach(function(virtual) {
var funcs = _virtuals[virtual];
props.schema.virtual(virtual)
.get(funcs.get || function() { })
.set(funcs.set || function() { });
})
}
Object.keys(props.options).forEach(function(opt){
switch (opt.toLowerCase()) {
case "usetimestamps":
if (String(props.options[opt]) === 'true')
props.schema.plugin(mongooseTypes.useTimestamps);
break;
case "usekeyword":
if (typeof props.options[opt] === 'object')
props.schema.plugin(keywordize, props.options[opt]);
break;
case "useaudit":
if (auditLog && typeof props.options[opt] === 'object'){
var pluginFn = auditLog.getPlugin('mongoose', props.options[opt]); // setup occurs here
props.schema.plugin(pluginFn.handler); // .handler is the pluggable function for mongoose in this case
}
break;
case "useelastic":
if (typeof props.options[opt] === 'object')
props.schema.plugin(mongoosastic, props.options[opt]);
break;
}
});
// Check if we are loading the timestamps plugin
if (props.hasOwnProperty('useTimestamps') && props.useTimestamps) {
props.schema.plugin(mongooseTypes.useTimestamps);
}
// Check if we are loading the keywordiez plugin
if (props.useKeyword && typeof props.useKeyword === 'object') {
props.schema.plugin(keywordize, props.useKeyword);
}
// Check if we are loading the audit-log plugin
if (auditLog && props.useAudit && typeof props.useAudit === 'object') {
var pluginFn = auditLog.getPlugin('mongoose', props.useAudit); // setup occurs here
props.schema.plugin(pluginFn.handler); // .handler is the pluggable function for mongoose in this case
}
// Check if we are loading the elasticsearch plugin
if (props.useElastic && typeof props.useElastic === 'object') {
props.schema.plugin(mongoosastic, props.useElastic);
}
// Bind any instance methods to the schema.methods object
if (props.methods) {
Object.keys(props.methods).forEach(function(i) {
props.schema.methods[i] = props.methods[i];
});
}
mongoose.Model.paginate = function(q, skipFrom, resultsPerPage, sortCols, selCols, callback){
var MyModel = this,
query,
pageCount= 0,
callback = callback || function(){};
if (skipFrom>0) {
query = MyModel.find(q).skip(skipFrom).limit(resultsPerPage).sort(sortCols).select(selCols);
}
else {
query = MyModel.find(q).limit(resultsPerPage).sort(sortCols).select(selCols);
}
query.exec(function(error, results) {
if (error) {
callback(error, null, null);
} else {
MyModel.count(q, function(error, count) {
if (error) {
callback(error, null, null);
} else {
pageCount = Math.floor(count / resultsPerPage);
callback(null, count, results);
}
});
}
});
}
// Create the mongoose model
var model = connection.model(name, props.schema, props.collection);
var excludeProps= ['schema', 'collection', 'useTimestamps', 'useKeyword', 'useAudit', 'useElastic', 'methods', 'statics', 'options', 'columns', 'funcs'];
// Copy over all other properties as static model properties
Object.keys(props).forEach(function(key) {
if (excludeProps.indexOf(key)<0) {
model[key] = props[key];
}
});
if (props.statics){
Object.keys(props.statics).forEach(function(key) {
model[key] = props.statics[key];
});
}
// Store the model
models[name].model = model;
// The model is done being built, allow circular reference to resolve
circles.emit(name, model);
return model;
};
var http = require('http');
var test = require('./test'); // Fait appel à users.js (même dossier)
// var test = require('../test'); // Fait appel à users.js (dossier parent)
var url = require('url');
var EventEmitter = require('events').EventEmitter;
var EventEmitter = require('events').EventEmitter;
var jeu = new EventEmitter();
jeu.on('gameover', function(message){
console.log(message);
});
jeu.emit('gameover', 'Vous avez perdu !');
var server = http.createServer(function(req, res) {
var page = url.parse(req.url).pathname;
console.log(page);
res.writeHead(200, {"Content-Type": "text/plain"});
res.write('Bien le bonjour');
test.direBonjour();
res.end();
});
server.listen(8080);
process.nextTick(function() {
cluster.emit('setup', settings);
});
console.log('连接成功。');
// 触发 data_received 事件
eventEmitter.emit('data_received');
}
// 绑定 connection 事件处理程序
eventEmitter.on('connection', connectHandler);
// 使用匿名函数绑定 data_received 事件
eventEmitter.on('data_received', function(){
console.log('数据接收成功。');
});
// 触发 connection 事件
eventEmitter.emit('connection');
console.log("程序执行完毕。");
/* ----------------------------------------------------- */
process.on('exit', function(code) {
// 以下代码永远不会执行
setTimeout(function() {
console.log("该代码不会执行");
}, 0);
console.log('退出码为:', code);
});
console.log("程序执行结束");
process.nextTick(function() {
cluster.emit('fork', worker);
});
old.pause = function() {
pauses++;
old.emit('pause');
flowing = false;
};
bufs.forEach(function (buf) {
stream.emit('data', buf);
});