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)
