function getResults (feedUrl, callback) {
var articles = [];
var error = function () {
callback([]);
};
var afterParseItem = function (item, feedType) {
item.customProp = 'customProp!';
};
var feedParser = FeedJett.createInstance({ parseRawNode: true, feedUrl: feedUrl, afterParseItem: afterParseItem });
feedParser.on('readable', function () {
var article;
while (article = this.read()) {
articles.push(article);
}
}).on('end', function () {
callback(articles);
})
.on('error', error);
request(feedUrl, {pool: false})
.on('response', function (res) {
if (res.statusCode != 200) {
return this.emit('error', new Error('Bad status code'));
}
res.pipe(feedParser);
})
.on('error', error);
}
HttpContext.prototype.engine = function(extension) {
var item = this.application.config.engines.find(function(x) { return x.extension===extension; });
if (item) {
var engine = require(item.type);
if (typeof engine.createInstance !== 'function') {
throw new Error('Invalid view engine module.')
}
return engine.createInstance(this);
}
};
function attachInstanceToGateway(gateway, callback){
ec2.createInstance(function(err, instance){
if (err) { callback(err); return };
gateway.ec2_instance_id = instance.InstanceId;
gateway.state = 'confirm_instance';
gateway.save().complete(function(){
callback(null, instance);
});
});
}
}, function(err) {
if (err) { callback(err); return; }
if (viewEngine) {
var engine = require(viewEngine.type);
/**
* @type {HttpViewEngine|*}
*/
var engineInstance = engine.createInstance(context);
//render
var e = { context:context, target:self };
context.emit('preExecuteResult', e, function(err) {
if (err) {
callback(err);
}
else {
engineInstance.render(viewPath, self.data, function(err, result) {
if (err) {
callback.call(context, err);
}
else {
//HttpViewResult.result or data (?)
self.result = result;
context.emit('postExecuteResult', e, function(err) {
if (err) {
callback.call(context, err);
}
else {
response.writeHead(200, {"Content-Type": self.contentType});
response.write(self.result, self.contentEncoding);
callback.call(context);
}
});
}
});
}
});
}
else {
var er = new common.HttpNotFoundException();
if (context.request && context.request.url) {
er.resource = context.request.url;
}
callback.call(context, er);
}
});
perform: function(gatewayId, callback) {
var client = new EC2Client()
var instance;
client.createInstance()
.then(function(created) {
console.log('created instance!', created)
return client.addTag(created['InstanceId'], 'Name', 'gatewayzen:gatewayd')
})
.then(function() {
callback(null, instance)
})
.error(function(error) {
console.log('error creating instance!', error)
callback(error)
})
}
channels: [settings.channel],
});
// Original IRC output to console (for debugging)
client.addListener('raw', function (message) {
if (message.server) {
console.log(':' + message.server + ' ' + message.command + ' ' + message.args.join(' :') );
} else {
console.log(':' + message.nick + '!' + message.user + '@' + message.host + ' ' +
message.command + ' ' + message.args.join(' :') );
}
});
// The Locale handler
var Locale = require(__dirname + '/components/locale.js');
var locale = Locale.createInstance(__dirname + '/locales', '.yaml');
locale.setLanguage(settings.language);
// The actual game
var Werewolf = require(__dirname + '/game/index.js');
var werewolf = Werewolf.createGame({
bot: settings,
irc: client,
channel: settings.channel,
admins: settings.admins,
locale: locale
});
//werewolf.start();
#!/usr/bin/env node
var MessageHub = require( __dirname + '/../index'),
config = require( __dirname + '/config' ).readMessageHubConfig(),
hub;
// don't run in background...
config.daemon = false;
hub = MessageHub.createInstance( config );
hub.start();
#!/usr/bin/env node
var config = require( __dirname + '/../config.json'),
LoggerService = require( __dirname + '/../index'),
service;
// don't run in background...
config.daemon = false;
console.log('message hub: ', config.hubName);
service = LoggerService.createInstance( config );
service.start();
#!/usr/bin/env node
var neo4ji = require(__dirname + '/neo4ji.js');
var args = require('minimist')(process.argv.slice(2));
var command = args._[0];
var instanceName = args._[1];
switch(command){
case "create":
console.log('creating: ' + instanceName + '...');
neo4ji.createInstance(instanceName, args.V)
break;
case "destroy":
console.log('destroying: ' + instanceName + '...');
neo4ji.destroyInstance(instanceName)
break;
case "start":
console.log('starting: ' + instanceName + '...');
neo4ji.startInstance(instanceName, args.V)
break;
case "stop":
console.log('stopping: ' + instanceName + '...');
neo4ji.stopInstance(instanceName)
break;
case "instances":