Example #1
0
        it('should fulfill a request/reply event', function (done) {
            var connection = amqp.createConnection({
                host: process.env.NYHOST,
                port: 5672,
                login: process.env.NYLOGIN,
                password: process.env.NYPASSWORD
            });

            connection.on('ready', function () {
                var nyply = new (require('../nyply'))(connection);
                nyply.call('test', { blah: 'blah' }, function response(err, response) {
                    assert.equal(response.response, 'OK');
                    done();
                }, 10000);
            });

            var responseConnection = amqp.createConnection({
                host: process.env.NYHOST,
                port: 5672,
                login: process.env.NYLOGIN,
                password: process.env.NYPASSWORD
            })

            responseConnection.on('ready', function () {
                responseConnection.queue('test', { 'durable': false, 'autoDelete': true }, function (q) {
                    q.subscribe(function (message, headers, deliveryInfo, m) {
                        responseConnection.publish(m.replyTo, { response: "OK", index: message.index }, {
                            contentType: 'application/json',
                            contentEncoding: 'utf-8',
                            correlationId: m.correlationId
                        });
                    });
                });
            });
        })
 t.test( 'get connections', function ( t ) {
     t.plan( 2 );
     connection1 = amqp.createConnection( {url:amqp_url} );
     connection2 = amqp.createConnection( {url:amqp_url} );
     connection1.on( 'ready', function () {
         t.ok( connection1, 'Got connection #1');
     });
     connection2.on( 'ready', function () {
         t.ok( connection2, 'Got connection #2');
     });
 });
    50, // limit
    function iterator(i, callback){
        var connection = amqp.createConnection({ host: 'localhost' });

        connection.on('error', amqpError);

        // log some progress
        if(i % 1000 === 0){
            console.log(('\t > ' + i + ' clients connected').blue);
        }
        
        connection.on('ready', function (err) {
            var exchange = connection.exchange('messages', {
                type: 'fanout'
            }, function() { });

            // setup queue
            var queue = connection.queue(
                'pubsub' + i,
                function (q) {
                    q.bind(exchange, "messages", function() { });
                    q.subscribe(function queueCallback (message, headers, deliveryInfo, messageObject){
                        // when message is received, increment counter
                        messagesReceived++;
                    });

                    // Conncetion finished
                    clientsConnected++;
                    callback();
            });

        });
    }, 
Example #4
0
exports.startServer = function(host) {
  host = host || 'localhost'
  var connection = amqp.createConnection({ host: host });

  connection.on('ready', function() {
    connection.queue('core-route',function(q) {
      console.log("READY");
      q.subscribe(function(msg) {
      console.log("hit");
        if(msg.method && commands[msg.method]) {
          var f = msg.method;
          f.call(msg.params);
        }
        else if(msg.method == 'route.register') {
          console.log("REG");
          console.log("params=" + JSON.stringify(msg.params));
          console.log(msg.toString('utf-8'));
        }
        else {
          console.log(msg.toString('utf-8'));
        }
      })
    })
  })
}
 superMinionStart(function(err, state) {
   if(err) {
     callback(err, state);
   } else {
     state.connection = amqpMod.createConnection(self.amqpConfig);
     state.connection.on('error', function(what) {
       options.logger('General Error: ' + util.inspect(what));
     });
     state.connection.on('ready', function() {
       Step(
         function workersExchange() {
           self.createWorkersExchange(state.connection, exchangeName, this);
         },
         function workersRetryExchange(workersExchange) {
           state.exchange = workersExchange;
           self.createWorkersRetryExchange(state.connection, exchangeName, this);
         },
         function done(workersRetryExchange) {
           state.exchangeRetry = workersRetryExchange;
           callback(undefined, state);
         }
       );
     });        
   }
 });
Example #6
0
var init = module.exports.init = function(mqConfig, callback) {
    if (!connection) {
        log().info('Initializing RabbitMQ connector.');

        connection = amqp.createConnection(mqConfig.connection);

        connection.on('error', function(err) {
            log().error({'err': err}, 'Error connecting to RabbitMQ.');
            return callback(err);
        });

        connection.on('close', function() {
            log().info('Closed connection to RabbitMQ');
        });

        connection.on('ready', function() {
            log().info('Connection to RabbitMQ established.');

            // Initialize the exchange for the job queues
            connection.exchange(Constants.DEFAULT_TASK_EXCHANGE_NAME, Constants.DEFAULT_TASK_EXCHANGE_OPTS, function(exchange) {
                queueExchange = exchange;
                return callback();
            });
        });
    } else {
        log().warn('Attempted to initialize an existing RabbitMQ connector. Ignoring');
        callback();
    }
};
    listen() {
        this.logger.info('listening for requests');
        this.connection = amqp.createConnection();
        // Wait for connection to become established.
        this.connection.on('ready', () => {
            this.logger.info('connected to rabbitmq');
            // Use the default 'amq.topic' exchange
            this.connection.queue('convert-request-queue', q => {
                // Catch all messages
                q.bind('#');

                // Receive messages
                q.subscribe(message => {
                    let data = message.data.toString('utf8');
                    let jsonMessage = JSON.parse(data);
                    switch(jsonMessage.action) {
                        case 'convert':
                            this._convert(jsonMessage.ticketId, jsonMessage.data);
                            break;
                        case 'cancel':
                            this._cancel(jsonMessage.ticketId);
                            break;
                        case 'cleanup':
                            this._clean(jsonMessage.data);
                            break;
                    }
                });
            });
        });
    }
Example #8
0
	followToAMQP = function (cfgCouch, cfgAMQP, format, condition) {
		condition = condition || function (cb) { cb(); };

		var connection = amqp.createConnection(cfgAMQP);
		
		connection.on('ready', function () {
			connection.exchange(cfgAMQP.exchange, {
				type: 'topic'
			}, function (exchange) {
				var db = url.parse(cfgCouch.db).pathname.substr(1);
				
				cfgCouch.include_docs = true;
				
				follow(cfgCouch, function (err, change) {
					condition (function () {
						if (!err) {
							var doc = change.doc,
								msg = (format || defaultFormat)(doc);
				
							if (msg.body) {
								exchange.publish(msg.name, msg.body, msg.options);
							}
						}
					});
				});
			});
		});
	};
function main( workerID )
    {
    var connection = amqp.createConnection({host: 'localhost'});
    var workerStr = workerID ? "W["+ workerID +"]" : "";

    connection.on('ready', function()
        {
        connection.queue('task_queue', {autoDelete: false, durable: true}, function(queue)
            {
            console.log('[*] Waiting for messages. To exit press CTRL+C');
            queue.subscribe({ack: true, prefetchCount: 1}, function (json, headers, info, message)
                {
                var body = json.data.toString('utf-8');
                console.log(" [*]%s Received %s", workerStr, body);
                setTimeout( function() 
                    {                    
                    var rnd = Math.floor((Math.random()*3)+1);
                    if ( rnd == 2 )
                        {
                        console.log( "   [x]%s Failed %s", workerStr, body );
                        message.reject(true);
                        //queue.shift(true, true); // NOT WORK: https://github.com/postwait/node-amqp/issues/210
                        }
                    else
                        {                
                        console.log( "   [√]%s Done %s", workerStr, body );
                        queue.shift(); // basic_ack equivalent
                        }
                    }, 4000 );
                });
            });
        });
    }
Example #10
0
function Context(opts) {
  EventEmitter.constructor.call(this);
  var that = this;
  var c = this._connection = amqp.createConnection(opts);
  c.on('ready', function() { that.emit('ready') });
  c.on('error', function(e) { that.emit('error', e) });
};
Example #11
0
module.exports.Client = function* (url) {
	var a = Object();

	info('AMQP Connect: ' + url);
	var defer = Q.defer();
	var conn = amqp.createConnection({url: url});
	conn.on('ready', function () {
		defer.resolve(a);
	});

	a.subscribe = function (exchange, routing_key, callback) {
		conn.queue('', function (q) {
			q.bind(exchange, routing_key, function () {
				q.subscribe(function (message, headers, deliveryinfo, messageObject) {
					var pkt = JSON.parse(message.data);
					callback(pkt);
				});
			});
		});
	}

	a.publish = function* (exchange, routing_key, pkt) {
		var defer2 = Q.defer();

		conn.exchange(exchange, {'passive': true}, function (xch) {
			xch.publish(routing_key, pkt);
			defer2.resolve();
		});

		return yield defer2.promise;
	}

	return yield defer.promise;
}
function initializeBrokerResourcesAndThen(doCallback, busSettings) {
    // init relayerConnection, deadletter exchange, queue and bind them. doCallback() when finished.
    busSettings = busSettings || {};
    relayerConnection = amqp.createConnection(busSettings);
    relayerConnection.on('ready', function () {
        relayerConnectionIsOk = true;
        logger.info('Creating', deadletterName, 'in:', relayerConnection.options);
        var queue = relayerConnection.queue(deadletterName, deadletterQueueOptions, function (deadletterQueue) {
            deadletterExchange = relayerConnection.exchange(deadletterName, deadletterExchangeOptions, function () {
                queue.bind(deadletterName, deadletterQueueRk, function () {
                    logger.info('Created queue[', deadletterName, '] exchange [', deadletterName, '] and binded with Routing Key [', deadletterQueueRk, ']');
                    if (doCallback) {
                        doCallback();
                    }
                })
            });
            deadletterExchange.on('error', _logError('Error creating deadletter exchange:'));
        });
        queue.on('error', _logError('Error creating deadletter queue: '));
    });
    relayerConnection.on('error', function (err) {
        logger.error('Error connecting to broker: ' + inspect(busSettings) + "Error: " + err);

        // eyeos-run-server should restart the service
        process.exit(1);
    });

    relayerConnection.on('close', function () {
        logger.info('Closed connection to broker: ' + inspect(busSettings));

        // eyeos-run-server should restart the service
        process.exit(1);
    });
}
Example #13
0
exports.connect = function(callback) {

	// Create the amqp connection to rabbitMQ server
	connection = amqp.createConnection(addr);
	connection.on('ready', function () {

		//Create a direct exchange
		exc = connection.exchange('rpcExchange', {type: 'direct'}, function (exchange) {
			logger.info('Exchange ' + exchange.name + ' is open');

			//Create the queue for send messages
	  		clientQueue = connection.queue('', function (q) {
			  	logger.info('ClientQueue ' + q.name + ' is open');

			 	clientQueue.bind('rpcExchange', clientQueue.name);

			  	clientQueue.subscribe(function (message) {

			  		if(map[message.corrID] !== undefined) {
			  			clearTimeout(map[message.corrID].to);
						map[message.corrID].fn(message.data);
						delete map[message.corrID];
					}
			  	});

			  	callback();
			});
		});
	});
}
function _openBusConnectionAndExchangeThenSend(userBusSettings, destinationName, busMessage) {
    var connection = amqp.createConnection(userBusSettings); // disposable connection for this request.
    connection.on('ready', function () {
        logger.debug('Connection established for user request:', connection.options);
        var exchange = connection.exchange(destinationName, {passive: true}, function () {
            logger.debug('Exchange opened for user request:', exchange.name, ' => publishing message.', busMessage);
            exchange.publish(busMessage.routingKey, JSON.stringify(busMessage));
            _closeConnection(connection, destinationName);
        });
        exchange.on('error', function (err) {
            logger.warn('Error on exchange: ', destinationName, err);
            // error in exchange usually means that user has no permissions or exchange does not exist. send to deadletter.
            _sendToDeadletter(destinationName, busMessage, err, userBusSettings);
            _closeConnection(connection, destinationName);
        })
    });
    connection.on('error', function (err) {
        debugger;
        logger.error('Error connecting to RabbitMQ for request: ', busMessage, '\nRequest connection Settings:', userBusSettings, '\nError:', err);
        // if relayerConnection is OK, send to deadletter exchange, and cancel reconnect
        // if relayerConnection is KO, we lost connection to broker. Maintain reconnect=true, eventually it should work.
        if (relayerConnectionIsOk) {
            // disable reconnect, since autoreconnect was enabled, connection will raise a 2nd error
            // for that reason, remove all error listeners and add a dummy listener, since the error is being handled now.
            _closeConnection(connection, destinationName);
            err.code = 401;
            err.codeDescription = 'Unauthorized';
            deadletterExchange.publish(destinationName, JSON.stringify({busMessage: busMessage, error: err, busSettings: userBusSettings}));
        } else {
            logger.warn('Lost connection to RabbitMQ. Error trying to publish on exchange: ', destinationName);
        }
    });
}
Example #15
0
Starsky.prototype.connect = function (callback) {
  debug('connect');

  var config = this.config;
  var options = {
      host: config.get('mq host')
    , port: config.get('mq port')
    , login: config.get('mq username')
    , password: config.get('mq password')
    , vhost: config.get('mq vhost')
    , heartbeat: config.get('mq heartbeat')
    , ssl: {
        enabled: config.get('mq tls')
      , keyFile: config.get('mq tls key')
      , certFile: config.get('mq tls cert')
    }
  };

  if ('function' == type(callback)) {
    this.on('connect', function listener () {
      this.removeListener('connect', listener);
      callback();
    });
  }

  this.connection = amqp.createConnection(options);
  this.connection.on('error', this.onConnectionError.bind(this));
  this.connection.on('close', this.onConnectionClose.bind(this));
  this.connection.on('ready', this.onConnectionReady.bind(this));
  this.connection.on('heartbeat', this.onConnectionHeartbeat.bind(this));
};
Example #16
0
  /** Private functions */

  /**
   * Setup the connection
   * @param  {Object} connectCfg AMQP connection configurations. 
   * @param  {Object} options    AMQP connection options. 
   * See https://github.com/postwait/node-amqp#connection-options-and-url for the format of the connectCfg and options
   */
  function setupConn(connectCfg, options) {
    var conn = amqp.createConnection(connectCfg, options);
    conn.on('ready', function(){
      debug('received ready event from node-amqp');
      var eventName = 'connection';
      //Ready event will be emitted when re-connected. 
      //To keep backward compatible, only emit 'connection' event for the first time
      if(_connection){
        eventName = 'reconnect';
      }
      _connection = conn;
      _connection._isClosed = false;
      self.emit('ready');
      // wrapped in 'nextTick' for unit test friendliness
      process.nextTick(function(){
        debug('going to emit ' + eventName);
        self.emit(eventName);
      });

      autoSubscribe();
      publishCachedMessages();
    });
    conn.on('error', function(err){
      self.emit('error', err);
    });
    conn.on('close', function(){
      if(_connection){
        _connection._isClosed = true;
      }
    });
  }
Example #17
0
App.prototype.setupAmqpClient = function () {
    var self = this;
    var connection = self.amqpConnection
        = amqp.createConnection(self.config.amqp, { log: self.log });

    connection.on('ready', function () {
        connection.connected = true;
        self.log.info('AMQP connection ready');

        self.moray.ensureClientReady(function () {

            self.ur.useConnection(self.amqpConnection);
            self.ur.bindQueues();
        });
    });

    connection.on('error', function (e) {
        connection.connected = false;
        self.log.error(e);
    });

    connection.on('end', function () {
        connection.connected = false;
    });

    // Set up Ur client.
    self.log.debug('Ready to communicate with ur');
    self.ur = new Ur({ log: self.log });
    self.ur.on('serverSysinfo', self.onSysinfoReceivedUr.bind(self));
};
Example #18
0
    self.backend.on('ready', function() {
        debug('Connecting to broker...');

        if (self.conf.broker_type === 'redis') {
            self.broker = new RedisBroker(self.conf);
        } else if (self.conf.broker_type === 'amqp') {
            self.broker = amqp.createConnection(self.conf.BROKER_OPTIONS, {
                defaultExchangeName: self.conf.DEFAULT_EXCHANGE
            });
        }

        self.broker.on('error', function(err) {
            self.emit('error', err);
        });

        self.broker.on('end', function() {
            self.emit('end');
        });

        self.broker.on('ready', function() {
            debug('Broker connected...');
            self.ready = true;
            debug('Emiting connect event...');
            self.emit('connect');
        });
    });
TrackingClient.prototype.start = function() {
	this.emit('log', 'starting');
	this.exchangeOpen = false;
	this.mqConnection = amqp.createConnection({url:this.mqUrl});
	this.mqConnection.on('ready', this.mqConnectionReady.bind(this));
	this.mqConnection.on('error', this.emit.bind(this));
};
Example #20
0
    P.connect = function() {

        var self = this;

        this.connection = amqp.createConnection({url: this.url});

        this.connection.on('ready', function () {

            var destroyQueue = function(callback) {
                var q = self.connection.queue(self.options.queueName, {durable:true, 'autoDelete': false}, function(queue) {
                    queue.destroy();
                    if (callback) callback();
                });
            };

            var startAdapter = function() {
                var adapter = require('./adapters/' + self.task);
                adapter.create(self, function(err) {
                    if (err) {
                        
                    } else {
                        self.emit('connection', self);
                    }
                });
            };

            if (self.options.clean) {
                destroyQueue(startAdapter);
            } else {
                startAdapter();
            }

        });

    };
Example #21
0
  fs.readFile(gitosisConfig, function(e, d) {
    if(e){
      sys.puts("[WARNING] Unable to read configuration file: " + gitosisConfig + " : " + e);
    } else {
      var config;
      
      try {
        config = ini.parse(d);
      } catch(err) {
        throw new Error("[ERROR] Unable to parse config file '" + gitosisConfig + "': " + err);
      }

      if(currentAMQPConnection){
        // This is an expected close event so we don't want to attempt reconnect on the
        // same handle
        currentAMQPConnection.removeListener('close', connectionCloseHandle);
        currentAMQPConnection.close();
        currentAMQPConnection = null;
      }
      var connection = amqp.createConnection({port:Number(config.amqp.port), host:config.amqp.host});
      connection.config = config;
      connection.addListener('close', connectionCloseHandle );
      connection.addListener('ready', connectionReadyHandle.bind(this,connection));  
      currentAMQPConnection = connection;
    }
  });
Example #22
0
    exports.init = function(queue, callback) {

        connection = amqp.createConnection({
            host: conf.RABBIT_HOST,
            port: conf.RABBIT_PORT
        });

        connection.on('ready', function() {
            conf.logger.log('[RabbitMQ] Connection established');

            connection.queue(queue, {
                durable: true,
                'exclusive': false,
                'autoDelete': false
            }, function(q) {
                conf.logger.log('[RabbitMQ] Queue declared');

                q.bind('#');
                q.subscribe(callback);
            });
        });

        connection.on('error', function() {
            conf.logger.warn('[RabbitMQ] Error', arguments);
        });

    };
Example #23
0
Rabbit.prototype.connect = function (config, readycallback) {
	var self = this;
	this.connection = amqp.createConnection(config.connection, { heartbeat: 1 });
	if (readycallback) this.on('ready', function(me) {
			readycallback(null, me); 
		} );

	this.connection.on('error', function (e) { 
			console.log("ERROR:",e);
		self.emit('error', self.exchanges, self.queues, e );
		process.nextTick(function () {
			self.exchange = []; // stop pointing to the old array
			self.queues= [];    // stop pointing to the old array
		});
	} );
	this.connection.on('close', function (e) {
			self.emit('close', self.exchanges, self.queues, e ) } );

	this.on('allDone', function () { 
			self.connection.end(); } );
	this.connection.on('ready', function () {
			self.on('Rabbit_Declare_Exchange', function (exchdef, callback) { 
				self.exchange(exchdef, callback); } );
			self.on('Rabbit_Declare_Queue', function (queuedef, callback) { 
				self.queue(queuedef, callback); } );
			// first the exchanges, then the queues!
			async.series(
					[ function (sercb) {
							if (config.exchanges) {
								async.map( config.exchanges, function (exchdef, mapcb) {
										self.emit('Rabbit_Declare_Exchange', exchdef, mapcb);
									}, function (error, results) {
										if (error) return sercb(error);
										sercb(null, results);
									} );
							} else {
								sercb();
							}
						}
					, function (sercb) {
							if (config.queues) {
								async.map( config.queues, function (queuedef, mapcb) {
										self.emit('Rabbit_Declare_Queue', queuedef, mapcb);
									}, function (error, results) {
										if (error) return sercb(error);
										sercb(null, results);
									} );
							} else {
								sercb();
							}
						}
					], function (error, results) {
						if (error) console.log("RABBIT ERROR CALLBACK", error);
						if (readycallback && error) return readycallback(error);
						if (error) throw error;
						self.emit('ready', self);
					}
				);
		} );
}
Example #24
0
File: app.js Project: B4U/TSKL
  function rabbitConnect (server) {
    var connection = amqp.createConnection({ host: server });

    connection.on('error', function(err){
      console.log("Rabbit error: ", err.message);
    });

    // Wait for connection to become established.
    connection.on('ready', function () {
      console.log('Rabbit connected to ' + server);

      // Skip current server
      if ( server !== settings.host ) {

        connection.queue(QUEUE_NAME, function(q){
          // Catch all messages
          q.bind('#');
          console.log('Rabbit queue[' + QUEUE_NAME + '] binded on server[' + server + ']');

          q.subscribe(function (message) {
            console.log("Rabbit message: ", message);
            tskl.addKey(message.origin, message.key);
          });

          mqConnections.push(connection);
        });

      } else {
        mqConn = connection;
      }

    });
  }
Example #25
0
/**
 * Initializes bus connection, exchanges and queue.
 * @param callback
 */
function initialize (callback){
    // Connect to bus
    connection = amqp.createConnection({ url: config.connectionURL });
    connection.on('ready', function() {
        console.log('[BUS] Connected to ' + connection.serverProperties.product);

        // declare "administration" AMQP exchange
        adminExchange = connection.exchange('administration', {
            type: 'topic',
            durable: 'true'
        });

        // declare agent-specific queue (named with agent hostname)
        queue = connection.queue(process.env.HOSTNAME, function(q){
            // Receive messages
            q.subscribe(function (message, headers, deliveryInfo) {
                console.log('[BUS] Received', deliveryInfo.routingKey, 'message:', message);
                var cb = listeners[deliveryInfo.routingKey];
                if (cb){
                    cb(message);
                } else {
                    console.log('[BUS] Routing key', deliveryInfo.routingKey, 'not handled. Message discarded.');
                }
            });

            callback(null);
        });
    });
}
Example #26
0
 setup = function() {
   
   clearTimeout(timer);
   timer = null;
   
   connection = amqp.createConnection(options, {reconnect: false});
   
   // the connection may become ready many times
   // the amqp library has a built-in retry mechanism
   connection.on('ready', function () {
     connection.exchange(argv['output-exchange'], {}, function (ex) {
       exchange = ex;
       emitter.emit('ready');
     });
   });
   
   // when the connection closes, cycle everything
   connection.on('close', cycle);
   
   // prevent error events from bubbling up as thrown exceptions
   connection.on('error', function(err){
     // design choice: don't cycle from here, only on 'close'
     // rationale: testing shows that many error events happen for each close event
     // alternative: call cycle and let the if(!timer) handle scheduling
   });
 };
Example #27
0
    init : function(){
        if(!this._bindFlag){
            this._client = amqp.createConnection(rabbitmqConfig.server_option);
            var _self = this;
            this._client.once("ready", function(){
                rabbitMqLog.info('SSOLogSendService class init method connection success! ');
                _self._bindFlag = true;
                //------
                _self._client.exchange(rabbitmqConfig.logExchangeName, {type:"topic"}, function(exchange){
                    rabbitMqLog.info('SSOLogSendService class init method  Exchange '+exchange.name+' is open! ');

                    _self._client.queue(rabbitmqConfig.logQueueName, function(queue){
                        rabbitMqLog.info('SSOLogSendService class init method  Queue '+queue.name+' is open! ');

                        queue.bind(exchange,rabbitmqConfig.logQueueName, function(){
                            _self._exchange = exchange;
                            _self._queue = queue;
                        });
                    });
                });
                /**this._client.once('heartbeat',function(){
                    rabbitMqLog.info('SSOLogSendService class init method heartbeat event');
                });*/
                _self._client.once('error', function(err){
                    _self.destroy();
                    throw new Error('rabbitmq connection error : '+err);
                });
            });
        }
    },
Example #28
0
exports.initialize = function(){
	
	//get the server status from the configuration file. this value should be true to use this
	var isMessagingServerRunning = serverConfig.status;
	
	
	if(isMessagingServerRunning === 'true'){
		logger.info('MessagingFactory', ' Starting AMQP Messaging server....');
		//create a connection to the external AMQP server
		connection = amqp.createConnection(serverConfig.server);
		connection.on('error', function(err){
			logger.error('MessagingFactory', 'Connection to the AMQP server failed!!.' +
					'Attempting to reconnect.....');
		});
		//start the subscribers
		amqpSubs.startSub(connection, eventSubs);
		logger.info('MessagingFactory', ' AMQP Messaging server Started');
	} else if(isMessagingServerRunning === 'false'){
		logger.info('MessagingFactory', ' AMQP Messaging server is not running');
	} else {
		logger.error('MessagingFactory', ' Syntax error. Check the variable \'amqp.status\' in \'server_config.json\'');
	}
	
	
}
Example #29
0
function Bus(options, implOpts) {
  var noop = function () {};
  options = options || {}, implOpts, self = this;
  options.url = options.url || process.env.RABBITMQ_URL || 'amqp://localhost';
  implOpts =  implOpts || { defaultExchangeName: 'amq.topic' };
  this.log = options.log || { debug: noop, info: noop, warn: noop, error: noop };
  
  this.delayOnStartup = options.delayOnStartup || 10;
  this.initialized = false;
  this.log.debug('connecting to rabbitmq on ' + options.url);
  this.connection = amqp.createConnection(options, implOpts);
  this.pubsubqueues = {};
  this.queues = {};

  var self = this;

  this.connection.on('error', function (err) {
    self.log.error('Error connecting to rabbitmq at '  + options.url + ' error: ' + err.toString());
    throw err;
  });

  this.connection.on('close', function (err) {
    self.log.debug('rabbitmq connection closed.');
  });

  this.connection.on('ready', function () {
    self.initialized = true;
    self.log.debug("rabbitmq connected to " + self.connection.serverProperties.product);
  });
}
Example #30
0
exports.getConnection = function (){
	
	
	if(connection != null){
		return connection;
	} else {
		var isMessagingServerRunning = serverConfig.status;
		
		
		if(isMessagingServerRunning === 'true'){
			logger.info('MessagingFactory', ' Starting AMQP Messaging server....');
			
			connection = amqp.createConnection(serverConfig.server);
			connection.on('error', function(err){
				logger.error('MessagingFactory', 'Connection to the AMQP server failed!!.' +
						'Attempting to reconnect.....');
			});

			logger.info('MessagingFactory', ' AMQP Messaging server Started');
		} else if(isMessagingServerRunning === 'false'){
			logger.info('MessagingFactory', ' AMQP Messaging server is not running');
		
		} else {
			logger.error('MessagingFactory', ' Syntax error. Check the variable \'amqp.status\' in \'server_config.json\'');
		}
		
		return connection;
	}
}