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())