def reconnect(self, callback): logger.info('Attempting to acquire the connect_lock.') if not self.connect_lock.acquire(False): logger.info('AsyncRabbitClient.reconnect is already ' 'attempting to connect (the connect_lock ' 'could not be acquired).') callback() return try: logger.info('AsyncRabbitClient.reconnect attempting to ' 'connect to host: %s' % self.host, extra={'host': self.host}) params = pika.ConnectionParameters(host=self.host) key = str(uuid.uuid4()) TornadoConnection(parameters=params, custom_ioloop=self.io_loop, on_open_callback=(yield gen.Callback(key))) logger.info('Waiting for TornadoConnection to return control ' 'via on_open_callback.') self.connection = yield gen.Wait(key) logger.info('Control has been returned.') logger.info('Opening a channel on the connection.') key = str(uuid.uuid4()) self.connection.channel(on_open_callback= (yield gen.Callback(key))) logger.info('Waiting for connection.channel to return control ' 'via on_open_callback.') self.channel = yield gen.Wait(key) logger.info('Control has been returned.') logger.info('Adding callbacks to warn us when the connection ' 'has been closed and when backpressure is being ' 'applied.') self.connection.add_on_close_callback(self.on_connection_closed) self.connection.add_backpressure_callback(self.on_backpressure) self.channel.add_on_close_callback(self.on_channel_closed) logger.info('Adding callbacks that are waiting for an open ' 'connection to the tornado queue.') while self.connection_open_callbacks: cb = self.connection_open_callbacks.pop() self.io_loop.add_callback(cb) logger.info('Done adding callbacks.') except Exception as e: logger.critical('An unknown exception was raised when trying ' 'to open a connection to rabbit: %s' % unicode(e)) raise finally: logger.info('Releasing the connect lock.') self.connect_lock.release() callback()
def start(self): if self._starting: return logger.info("Starting the connection") self._starting = True self._connection = TornadoConnection(pika.URLParameters(self._url), self.on_connection_open, self.on_connection_error, self.on_connection_error)
def connect(self): if self.connecting: LOGGER.info('Already connected to RabbitMQ server') return LOGGER.info('Opening a connection to RabbitMQ server') self.connecting = True self.connection = TornadoConnection( parameters=settings.pika_parameters, on_open_callback=self.on_connection_open) self.connection.add_on_close_callback(self.on_closed)
def connect(self): if self.is_connecting: logger.info("PikaConnection: Already connecting to RabbitMQ") return logger.info("PikaConnection: Connecting to RabbitMQ") self.connecting = True self.connection = TornadoConnection( pika.URLParameters(self.url), on_open_callback=self.on_connected) self.connection.add_on_close_callback(self.on_closed)
def connect(self): """ Creates connection to RabbitMQ server """ if self.connecting: log.info('PikaClient: Already connecting to RabbitMQ') return log.info('PikaClient: Connecting to RabbitMQ') self.connecting = True self.connection = TornadoConnection(NON_BLOCKING_MQ_PARAMS, stop_ioloop_on_close=False, custom_ioloop=self.io_loop, on_open_callback=self.on_connected)
def connect(self): if self.connecting: return self.connecting = True cred = pika.PlainCredentials('guest', 'guest') param = pika.ConnectionParameters( host='localhost', port=5672, virtual_host='/', credentials=cred ) self.connection = TornadoConnection(param, on_open_callback=self.on_connected)
def connect(cls, url): f = Future() def on_open(conn): f.set_result(cls(conn)) def on_open_error(conn, err): f.set_exception(AMQPConnectionError(err)) def on_close(conn): LOGGER.debug('connection closed: %s', conn) TornadoConnection( URLParameters(url), on_open_callback=on_open, on_open_error_callback=on_open_error, on_close_callback=on_close, ) return f
def open(self, callback=None): if self._starting: if callback: callback() return self._starting = True logger.info("Openning AMQP transport") if self._channel is not None and self._channel.is_open: logger.info("Already set") if callback: callback() else: logger.info("Openning connection") self._callback = callback self._lock.acquire() self._connection = TornadoConnection(pika.URLParameters(self._url), self.on_connection_open, self.on_connection_error, self.on_connection_error)
def connect(self, ioloop=None, stop_ioloop=True): logger.debug('Connecting to %s', self._url) self.stop_ioloop = stop_ioloop return TornadoConnection(URLParameters(self._url), self.on_connection_open, custom_ioloop=ioloop)