def test_tornado_connection():
from pika.adapters import tornado_connection
def on_open(connection):
connection.channel(on_open_callback=on_channel_open)
def on_channel_open(channel):
channel.basic_publish(
exchange='',
routing_key=QUEUE,
body='test',
)
connection.close()
connection.ioloop.stop()
parameters = pika.ConnectionParameters(DB_SETTINGS['host'])
connection = tornado_connection.TornadoConnection(parameters=parameters,
on_open_callback=on_open)
try:
connection.ioloop.start()
except:
connection.close()
# Start the IOLoop again so Pika can communicate, it will stop on its
# own when the connection is closed
connection.ioloop.start()
raise
def _new_rabbitmq_connection(self):
"""Return a connection to RabbitMQ via the pika.Connection object.
When RabbitMQ is connected, on_rabbitmq_open will be called.
:rtype: pika.adapters.tornado_connection.TornadoConnection
"""
return tornado_connection.TornadoConnection(self._rabbitmq_parameters,
self.on_rabbitmq_conn_open)
def connect(self):
logger.info("Coelho version %s connecting %s RPC Client to the AMPQ "
"broker." % (get_version(), self._name))
self._connecting = True
tornado_connection.TornadoConnection(
self.parameters,
on_open_callback=self.on_connection_opened,
on_open_error_callback=self.on_connection_failed,
on_close_callback=self.on_connection_closed)
def test_tornado_connection_timeout(self):
with self.assertRaises(exceptions.AMQPConnectionError):
with mock.patch(
'pika.TornadoConnection._create_tcp_connection_socket',
return_value=mock.Mock(
spec_set=socket.socket,
connect=mock.Mock(
side_effect=mock_timeout))) as create_sock_mock:
params = pika.ConnectionParameters(socket_timeout=2.0)
tornado_connection.TornadoConnection(params)
create_sock_mock.return_value.settimeout.assert_called_with(2.0)
def connect(self):
if self.connecting:
return
self.connecting = True
cred = pika.PlainCredentials('root', '123')
param = pika.ConnectionParameters(host="127.0.0.1", credentials=cred)
self.connection = tornado_connection.TornadoConnection(
param,
custom_ioloop=self.io_loop,
on_open_callback=self.on_connected)
self.connection.add_on_open_error_callback(self.error)
self.connection.add_on_close_callback(self.on_closed)
def connect(self):
"""Create the low-level AMQP connection to RabbitMQ.
:rtype: pika.adapters.tornado_connection.TornadoConnection
"""
self.set_state(self.STATE_CONNECTING)
self.handle = tornado_connection.TornadoConnection(
self._connection_parameters,
on_open_callback=self.on_open,
on_open_error_callback=self.on_open_error,
stop_ioloop_on_close=False,
custom_ioloop=self.io_loop)
def connect(self):
if self.connecting:
return
self.connecting = True
cred = pika.PlainCredentials(USER, PAWD)
param = pika.ConnectionParameters(host=HOST,
port=int(PORT),
credentials=cred)
self.connection = tornado_connection.TornadoConnection(
param,
custom_ioloop=self.io_loop,
on_open_callback=self.on_connected)
self.connection.add_on_open_error_callback(self.err)
self.connection.add_on_close_callback(self.on_closed)
def _connect(self):
"""Connect to RabbitMQ"""
LOGGER.info("Connecting to %s:%s:%s as %s",
self._host, self._port, self._virtual_host, self._username)
conn = pika.ConnectionParameters(self._host,
self._port,
self._virtual_host,
pika.PlainCredentials(self._username,
self._password),
connection_attempts=2)
return pika_adapter.TornadoConnection(conn,
self._on_connect,
self._on_connection_error,
self._on_connection_closed)
def test_tornado_connection_timeout(self):
with self.assertRaises(exceptions.AMQPConnectionError) as err_ctx:
with mock.patch(
'pika.TornadoConnection'
'._create_tcp_connection_socket',
return_value=mock.Mock(
spec_set=socket.socket,
connect=mock.Mock(
side_effect=mock_timeout))) as create_sock_mock:
params = pika.ConnectionParameters(socket_timeout=2.0)
ioloop = tornado_connection.ioloop.IOLoop()
self.addCleanup(ioloop.close)
conn = tornado_connection.TornadoConnection(
params, custom_ioloop=ioloop)
conn._on_connect_timer()
create_sock_mock.return_value.settimeout.assert_called_with(2.0)
self.assertIn('timeout', str(err_ctx.exception))
def connect_to_rabbitmq(self, cfg, name):
"""Connect to RabbitMQ returning the connection handle.
:param dict cfg: The Connections section of the configuration
:param str name: The name of the connection
:rtype: pika.adapters.tornado_connection.TornadoConnection
"""
LOGGER.debug('Connecting to %s:%i:%s as %s', cfg[name]['host'],
cfg[name]['port'], cfg[name]['vhost'], cfg[name]['user'])
self.set_state(self.STATE_CONNECTING)
self.connection_id += 1
hb_interval = cfg[name].get('heartbeat_interval', self.HB_INTERVAL)
parameters = self.get_connection_parameters(
cfg[name]['host'], cfg[name]['port'], cfg[name]['vhost'],
cfg[name]['user'], cfg[name]['pass'], hb_interval)
return tornado_connection.TornadoConnection(parameters,
self.on_connection_open,
stop_ioloop_on_close=False)
def __init__(self, host, port, virtual_host, user, password):
"""Construct our RabbitMQ object for use on the Tornado IOLoop
:param host: RabbitMQ server host
:type host: str
:param port: RabbitMQ server port
:type port: int
:param virtual_host: RabbitMQ virtual host to use
:type virtual_host: str
:param user: RabbitMQ user to connect as
:type user: str
:param password: RabbitMQ user's password
:type paassword: str
"""
# Create a logger instance
self._logger = logging.getLogger(__name__)
# We don't have a valid connection until the initial connect is done
self._connection = None
# We don't have a channel until we're connected
self._channel = None
# Set our app_id for publishing messages
self.app_id = "%s/%s" % (RabbitMQ.DEFAULT_APP_ID, __version__)
# Set our delivery mode for publishing messages
self.delivery_mode = RabbitMQ.DEFAULT_DELIVERY_MODE
# Set our encoding for publishing messages
self.encoding = RabbitMQ.DEFAULT_ENCODING
# Create our credentials
creds = credentials.PlainCredentials(username=user, password=password)
# Create the connection parameters
self.params = connection.ConnectionParameters(
host=host, port=port, virtual_host=virtual_host, credentials=creds)
# Create a new connection
tornado_connection.TornadoConnection(self.params, self._on_connected)
def connect(self):
"""This method connects to RabbitMQ, returning the connection handle.
When the connection is established, the on_connection_open method
will be invoked by pika.
:rtype: pika.SelectConnection
"""
rabbit_conf_dict = self.config_dict['rabbit']
self._logger.info('Connecting to %s:%s' %
(rabbit_conf_dict['ip'], rabbit_conf_dict['port']))
# return tornado_connection.TornadoConnection(pika.URLParameters(self._url), self.on_connection_open)
credentials = pika.PlainCredentials(rabbit_conf_dict['user'],
rabbit_conf_dict['password'])
parameters = pika.ConnectionParameters(host=rabbit_conf_dict['ip'],
port=rabbit_conf_dict['port'],
heartbeat=0,
credentials=credentials)
return tornado_connection.TornadoConnection(parameters,
self.on_connection_open)
def test_tornado_connection_call_parent(self, mock_init):
_SelectorIOServicesAdapter = (
selector_ioloop_adapter.SelectorIOServicesAdapter)
bucket = []
def construct_io_services_adapter(ioloop):
adapter = _SelectorIOServicesAdapter(ioloop)
bucket.append(adapter)
return adapter
with mock.patch('pika.adapters.utils.selector_ioloop_adapter.SelectorIOServicesAdapter',
side_effect=construct_io_services_adapter):
tornado_connection.TornadoConnection()
mock_init.assert_called_once_with(
None, None, None, None,
bucket[0],
internal_connection_workflow=True)
self.assertIs(bucket[0].get_native_ioloop(),
tornado_connection.ioloop.IOLoop.instance())
def test_tornado_connection_call_parent(self, mock_init):
obj = tornado_connection.TornadoConnection()
mock_init.called_once_with(None, None, False)
def test_tornado_connection_timeout(self, connect, settimeout):
connect.side_effect = mock_timeout
with self.assertRaises(exceptions.AMQPConnectionError):
params = pika.ConnectionParameters(socket_timeout=2.0)
tornado_connection.TornadoConnection(params)
settimeout.assert_called_with(2.0)
start_time = time.time()
channel.tx_select()
consumer_tag = channel.basic_consume(on_message, ROUTING_KEY)
def on_channel_open(channel_opened):
global channel
LOGGER.info('Channel opened')
channel = channel_opened
channel.queue_declare(on_queue_declared, ROUTING_KEY,
auto_delete=True, durable=True, exclusive=True)
def on_open(connection):
LOGGER.info('Connection opened')
connection.channel(on_channel_open)
logging.basicConfig(level=logging.INFO)
LOGGER.info('Starting benchmark with TX %s', TX)
parameters = pika.URLParameters('amqp://*****:*****@localhost:5672/%2F')
connection = tornado_connection.TornadoConnection(parameters=parameters,
on_open_callback=on_open,
stop_ioloop_on_close=True)
try:
connection.ioloop.start()
except KeyboardInterrupt:
connection.close()
connection.ioloop.start()
def test_tornado_connection_call_parent(self, mock_init):
obj = tornado_connection.TornadoConnection()
mock_init.assert_called_once_with(
None, None, None, None,
tornado_connection.ioloop.IOLoop.instance())
