PubSubRabbit.prototype.connect = function (opts) {
var _this = this;
var context = rabbit.createContext(opts.uri);
var deferred = promise.defer();
context.on('error', deferred.reject);
context.on('ready', function () {
var socket = context.socket(pubSub.PubSubTypes[opts.type].toUpperCase());
socket.connect(opts.queue, function (res) {
if (res && res.status == "error") {
deferred.reject(res);
}
else {
_this.context = context;
_this.socket = socket;
if (opts.onSub) {
_this.socket.setEncoding("utf8");
_this.socket.on("data", function (data) {
var json;
try {
json = JSON.parse(data);
}
catch (err) {
console.log("Failed to parse data", data);
return;
}
opts.onSub(json);
});
}
deferred.resolve();
}
});
});
return deferred.promise;
};
return new Promise((resolve) => {
if (_context) {
resolve(_context)
} else {
_context = rabbit.createContext(`amqp://${process.env.RABBITMQ || '192.168.99.100'}`)
_context.on('ready', () => {
resolve(_context)
})
}
})
app.post('/boards', function(req, res) {
var context = rabbitmq.createContext('amqp://'+process.env.RABBITMQ_PORT_5672_TCP_ADDR+':5672');
logger.log('info', 'board.new received: ' + req.body);
// call the board generator with the rabbit mq context, the board data and type and a callback
board.create(context, req.body, req.get('Content-Type'), function(err, result) {
if (!err){
logger.log('info', 'Success');
res.json(result);
} else {
logger.log('error', err);
res.status(400).json(result);
}
});
});
wifi.start = function(db) {
var context = rabbit.createContext();
context.on('ready', function() {
var sub = context.socket('SUB'); // subscription
sub.setEncoding('utf-8');
sub.connect(config.EXCHANGE_NAME, '', function() {
sub.on('data', function(data) {
console.log('got data from rabbitmq: ' + data);
if (utils.isMacAddress(data)) {
consume(db, data);
}
});
});
});
context.on('error', function(err) {
// attaching the error handler and re-throwing the error here makes it
// slightly easier to debug
throw err;
});
};
function createContext(next) {
context = rabbit.createContext(config.AMQP_HOST);
context.on('ready', function () {
info('RabbitMQ connected.');
next();
});
context.on('error', function (e) {
error(e);
});
context.on('close', function () {
error('RabbitMQ closed.');
info('RabbitMQ try to reconnect... ' + reconnectCount);
if (reconnectCount++ < 10)
setTimeout(exports.connect, 2000);
else {
error('RabbitMQ connection fail');
error('Server is shutting down...');
process.exit(1);
}
});
}
var logger = require('./lib/logger'),
rabbitmq = require('rabbit.js'),
router = require('./lib/router');
logger.info('board: running');
var context = rabbitmq.createContext(
'amqp://' + process.env.RABBITMQ_PORT_5672_TCP_ADDR + ':' + process.env.RABBITMQ_PORT_5672_TCP_PORT
);
context.on('ready', function () {
logger.info('board: connected');
// subscribe to pub and sub queues
var sub = context.socket('SUB'),
pub = context.socket('PUB');
pub.connect('events', function () {
sub.connect('events', function () {
// deal with facts as they come in
sub.on('data', function (body) {
logger.info("new fact : " + body);
router.newFact(pub, JSON.parse(body));
});
});
});
});
var rabbit = require('rabbit.js');
var context = rabbit.createContext();
var publish = context.socket('PUB');
var subscribe = context.socket('SUB');
var serviceName;
module.exports.init = function (srvName, callback) {
serviceName = srvName;
context.on('ready', function() {
subscribe.connect('events', function() {
publish.connect('events', function() {
callback();
});
});
});
};
module.exports.emit = function (eventName, params) {
publish.write(JSON.stringify({
eventName: eventName,
params: params || {},
timestamp: Date.now(),
service: serviceName
}));
};
module.exports.on = function (eventName, callback) {
subscribe.on('data', function (data) {
var event = JSON.parse(data);
if (event.eventName === eventName) {
callback(event.params);
Coyote.prototype.initContext = function() {
this.context = rabbit.createContext(this.amqpUri);
};
var express = require("express");
var validator = require('validator');
var rabbit = require('rabbit.js');
var ctx = rabbit.createContext();
var pub = ctx.socket('PUSH');
var signup = ctx.socket('PUSH');
var redis = require('redis').createClient();
var app = express();
var config = require('./config');
var db = require('./lib/mysql')(config.db);
var bodyParser = require('body-parser');
var extend = require('util')._extend;
var Datastore = require('nedb');
var Invitations = new Datastore({filename: 'invitations.db', autoload: true});
app.use(express.static(__dirname + '/public'));
app.set('view engine', 'ejs');
app.set('views', __dirname + '/views');
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.get('/', function(req, res){
res.render('mainpage');
});
app.get('/signup/:confirmationKey', function(req, res){
db.query('SELECT id, email FROM emails WHERE confirmation_key = ?',
[req.params.confirmationKey],
function(err, record){
module.exports = function (config) {
config = config || {};
var context = rabbit.createContext(config.context || rabbitCtx);
var defaults = _.defaults(config.defaults || {}, socketDefaults);
//
// on connection to rabbit
//
context.on('ready', function () {
// for every socket
_.each(config.sockets, function (socket) {
socket = _.defaults(socket, defaults);
// set up the socket
var sockInstance = context.socket(socket.type, socket.options);
sockInstance.setEncoding('utf8');
// find controller definition
var controller = null;
if (_.isString(socket.controller)) {
if (!config.controllers) {
throw new Error('A controller directory is required to string based controllers');
}
config.controllers = /\/$/.test(config.controllers) ? config.controllers : config.controllers + '/'
var ctrlSplit = (socket.controller || '').split('.');
var ctrlPath = config.controllers + ctrlSplit[0];
var ctrlHandler = ctrlSplit[1];
try {
controller = require(ctrlPath);
if (ctrlHandler) {
controller = controller[ctrlHandler];
}
} catch (e) {
if (!~e.message.indexOf('Cannot find module \'' + ctrlPath + '\'')) {
console.log(e.stack)
}
console.log('! Controller ' + socket.controller + ' not found verify path and handler: ' + ctrlPath + ' [' + ctrlHandler+ ']')
return;
}
} else if (_.isFunction(socket.controller)) {
controller = socket.controller;
} else {
throw new Error('Controller of type ' + (typeof socket.controller) + ' must be a Function or String');
}
// define the connection details
if (socket.topic) {
sockInstance.connect(socket.channel, socket.topic);
} else {
sockInstance.connect(socket.channel);
}
//
// bind the socket to the event
//
sockInstance.on(socket.listen, function(data){
var socketReq = {
context : context,
channel : socket.channel,
controller : config.controllers ? socket.controller : 'anonymous_controller',
message : data,
};
var coreFunction = co(function *(){
if (config.json) {
try {
socketReq.json = JSON.parse(data);
} catch (e) {
console.log(e.stack)
throw new Error('Failed to parse message:\n' + data);
}
}
if (config.middleware) {
yield config.middleware.call(socketReq, function *() {
yield controller.call(socketReq);
});
} else {
yield controller.call(socketReq);
}
});
var genericError = function *(err) { console.log(err.stack); }
if (config.error) {
coreFunction.catch(function (err) {
co(function *() {
yield config.error.call(socketReq, err);
}).catch(genericError);
});
} else {
coreFunction.catch(genericError)
}
});
});
});
}
// For interactive use
exports.sockjs = sjs;
exports.http = app;
// ==== Client connections
sjs.on('connection', function(c) {
clientConnection(c);
});
// Sockets for us to communicate with the "backend" services
var scheduler_proxy = {};
var context = rjs.createContext();
context.on('ready', function() {
var updates = context.socket('SUB');
updates.setEncoding('utf8');
updates.on('data', injectUpdate);
updates.connect('updates');
var subscriptions = context.socket('PUSH');
subscriptions.connect('subscriptions');
// Not convinced about this proxy thing.
scheduler_proxy.subscribe = function(topic) {
subscriptions.write(JSON.stringify({subscribe: topic}));
}
});
var initializeRabbitMQ = function(callback){
_context = rabbit.createContext(config.rabbit.url);
_context.on('ready', function(){ callback(null); });
};
var rabbitjs = require('rabbit.js');
//var amqp = require('amqp');
var queueSocket = "amqp://localhost";
var exchangeName = "Gems.Individual.Events.Status.Fanout";
var message = {
Name : "Vignesh Munirajan",
LogCorrelationId : 123,
Body : null
};
var encoding = "utf8";
var context = rabbitjs.createContext(queueSocket);
var publisher = context.socket("PUB", {routing: 'fanout', persistent: false});
publisher.connect(exchangeName, function(){
console.log("Connected");
var data = JSON.stringify(message);
var i = 0;
do {
i += 1;
publisher.write(data, encoding);
console.log("[%s] Message Published: %s", i,data);
} while (i < 10);
console.log(data);
//publisher.write(message);
})
//context.close();