def create_or_get_instance(rabbitmq_conf): global __conn if __conn is None: connection_conf = [] creds = credentials.PlainCredentials(rabbitmq_conf['user'], rabbitmq_conf['pass']) hosts = rabbitmq_conf['hosts'] for host_idx in range(len(hosts)): params = connection.ConnectionParameters(host=hosts[host_idx], credentials=creds) if host_idx == len(hosts) - 1: params.connection_attempts = rabbitmq_conf[ 'connection_attempts'] params.retry_delay = rabbitmq_conf['retry_delay'] connection_conf.append(params) try: __conn = adapters.select_connection.SelectConnection( connection_conf, custom_ioloop=IOLoop.current()) __conn.add_on_close_callback( RabbitMq._on_connection_close(rabbitmq_conf)) except AMQPConnectionError as e: print( f'Failed to connect to any of the RabbitMq hosts {hosts} because {e}' ) raise e return __conn
def test_blocked_connection_multiple_unblocked_in_a_row_removes_timer_once( self, connect_mock, call_later_mock, remove_timeout_mock): with mock.patch.object(ConstructibleConnection, '_adapter_connect_stream'): conn = ConstructibleConnection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) # Simulate Connection.Blocked conn._on_connection_blocked( conn, mock.Mock(name='frame.Method(Connection.Blocked)')) self.assertIsNotNone(conn._blocked_conn_timer) timer = conn._blocked_conn_timer # Simulate Connection.Unblocked conn._on_connection_unblocked( conn, mock.Mock(name='frame.Method(Connection.Unblocked)')) # Check conn._adapter_remove_timeout.assert_called_once_with(timer) self.assertIsNone(conn._blocked_conn_timer) # Simulate Connection.Unblocked again conn._on_connection_unblocked( conn, mock.Mock(name='frame.Method(Connection.Unblocked)')) self.assertEqual(conn._adapter_remove_timeout.call_count, 1) self.assertIsNone(conn._blocked_conn_timer)
def new_mock_parameters(self, host, port, vhost, user, password): mock_credentials = credentials.PlainCredentials(user, password) mock_credentials.username = user mock_credentials.password = password mock_parameters = connection.ConnectionParameters( host, port, vhost, mock_credentials) return mock_parameters
def test_blocked_connection_multiple_unblocked_in_a_row_removes_timer_once( self, connect_mock, add_timeout_mock, remove_timeout_mock): conn = connection.Connection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) # Simulate Connection.Blocked conn._on_connection_blocked( mock.Mock(name='frame.Method(Connection.Blocked)')) self.assertIsNotNone(conn._blocked_conn_timer) timer = conn._blocked_conn_timer # Simulate Connection.Unblocked conn._on_connection_unblocked( mock.Mock(name='frame.Method(Connection.Unblocked)')) # Check conn.remove_timeout.assert_called_once_with(timer) self.assertIsNone(conn._blocked_conn_timer) # Simulate Connection.Unblocked again conn._on_connection_unblocked( mock.Mock(name='frame.Method(Connection.Unblocked)')) self.assertEqual(conn.remove_timeout.call_count, 1) self.assertIsNone(conn._blocked_conn_timer)
def test_good_connection_parameters(self): """make sure connection kwargs get set correctly""" kwargs = { 'backpressure_detection': False, 'blocked_connection_timeout': 10.5, 'channel_max': 3, 'client_properties': {'good': 'day'}, 'connection_attempts': 2, 'credentials': credentials.PlainCredentials('very', 'secure'), 'frame_max': 40000, 'heartbeat': 7, 'host': 'https://www.test.com', 'locale': 'en', 'port': 5678, 'retry_delay': 3, 'socket_timeout': 100.5, 'ssl': True, 'ssl_options': {'ssl': 'options'}, 'virtual_host': u'vvhost', } params = connection.ConnectionParameters(**kwargs) # Verify expected_values = copy.copy(kwargs) # Make sure we're testing all public properties self.assertSequenceEqual(sorted(expected_values), sorted(_ALL_PUBLIC_PARAMETERS_PROPERTIES)) # Check property values for t_param in expected_values: value = getattr(params, t_param) self.assertEqual(expected_values[t_param], value, msg='Expected %s=%r, but got %r' % (t_param, expected_values[t_param], value))
def test_client_properties_override(self): expectation = { 'capabilities': { 'authentication_failure_close': True, 'basic.nack': True, 'connection.blocked': True, 'consumer_cancel_notify': True, 'publisher_confirms': True } } override = { 'product': 'My Product', 'platform': 'Your platform', 'version': '0.1', 'information': 'this is my app' } expectation.update(override) params = connection.ConnectionParameters(client_properties=override) with mock.patch.object(ConstructibleConnection, '_adapter_connect_stream'): conn = ConstructibleConnection(params) self.assertDictEqual(conn._client_properties, expectation)
def test_good_connection_parameters(self): """make sure connection kwargs get set correctly""" kwargs = { 'host': 'https://www.test.com', 'port': 5678, 'virtual_host': u'vvhost', 'channel_max': 3, 'frame_max': 40000, 'credentials': credentials.PlainCredentials('very', 'secure'), 'heartbeat_interval': 7, 'backpressure_detection': False, 'retry_delay': 3, 'ssl': True, 'connection_attempts': 2, 'locale': 'en', 'ssl_options': {'ssl': 'options'} } conn = connection.ConnectionParameters(**kwargs) #check values for t_param in ('host', 'port', 'virtual_host', 'channel_max', 'frame_max', 'backpressure_detection', 'ssl', 'credentials', 'retry_delay', 'connection_attempts', 'locale'): self.assertEqual(kwargs[t_param], getattr(conn, t_param), t_param) self.assertEqual(kwargs['heartbeat_interval'], conn.heartbeat)
def test_blocked_connection_timeout_terminates_connection( self, connect_mock, add_timeout_mock, on_terminate_mock): with mock.patch.multiple(ConstructibleConnection, _adapter_connect_stream=mock.Mock(), _terminate_stream=mock.Mock()): conn = ConstructibleConnection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) conn._on_connection_blocked( conn, mock.Mock(name='frame.Method(Connection.Blocked)')) conn._on_blocked_connection_timeout() # Check conn._terminate_stream.assert_called_once_with(mock.ANY) exc = conn._terminate_stream.call_args[0][0] self.assertIsInstance(exc, exceptions.ConnectionBlockedTimeout) self.assertSequenceEqual(exc.args, ['Blocked connection timeout expired.']) self.assertIsNone(conn._blocked_conn_timer)
def test_blocked_connection_multiple_blocked_in_a_row_sets_timer_once( self, connect_mock, add_timeout_mock): conn = connection.Connection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) # Simulate Connection.Blocked trigger conn._on_connection_blocked( mock.Mock(name='frame.Method(Connection.Blocked)')) # Check conn.add_timeout.assert_called_once_with( 60, conn._on_blocked_connection_timeout) self.assertIsNotNone(conn._blocked_conn_timer) timer = conn._blocked_conn_timer # Simulate Connection.Blocked trigger again conn._on_connection_blocked( mock.Mock(name='frame.Method(Connection.Blocked)')) self.assertEqual(conn.add_timeout.call_count, 1) self.assertIs(conn._blocked_conn_timer, timer)
def test_explicit_ssl_with_explict_port(self): params = connection.ConnectionParameters( ssl_options=connection.SSLOptions(ssl.create_default_context()), port=99) self.assertIsNotNone(params.ssl_options) self.assertEqual(params.port, 99)
def test_deprecated_heartbeat_interval(self): with warnings.catch_warnings(record=True) as warnings_list: warnings.simplefilter('always') params = connection.ConnectionParameters(heartbeat_interval=999) self.assertEqual(params.heartbeat, 999) # Check that a warning was generated self.assertEqual(len(warnings_list), 1) self.assertIs(warnings_list[0].category, DeprecationWarning)
def establish_connection(self): """Establish connection to the AMQP broker.""" conninfo = self.client for name, default_value in self.default_connection_params.items(): if not getattr(conninfo, name, None): setattr(conninfo, name, default_value) credentials = connection.PlainCredentials(conninfo.userid, conninfo.password) return self.Connection(connection.ConnectionParameters( conninfo.hostname, port=conninfo.port, virtual_host=conninfo.virtual_host, credentials=credentials))
def test_create_with_blocked_connection_timeout_config( self, add_on_unblocked_callback_mock, add_on_blocked_callback_mock, connect_mock): conn = connection.Connection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) # Check conn.add_on_connection_blocked_callback.assert_called_once_with( conn._on_connection_blocked) conn.add_on_connection_unblocked_callback.assert_called_once_with( conn._on_connection_unblocked)
def test_connection_blocked_sets_timer(self, connect_mock, add_timeout_mock): conn = connection.Connection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) conn._on_connection_blocked( mock.Mock(name='frame.Method(Connection.Blocked)')) # Check conn.add_timeout.assert_called_once_with( 60, conn._on_blocked_connection_timeout) self.assertIsNotNone(conn._blocked_conn_timer)
def test_connection_blocked_sets_timer(self, connect_mock, add_timeout_mock): with mock.patch.object(ConstructibleConnection, '_adapter_connect_stream'): conn = ConstructibleConnection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) conn._on_connection_blocked( conn, mock.Mock(name='frame.Method(Connection.Blocked)')) # Check conn._adapter_add_timeout.assert_called_once_with( 60, conn._on_blocked_connection_timeout) self.assertIsNotNone(conn._blocked_conn_timer)
def test_create_with_blocked_connection_timeout_config( self, add_on_unblocked_callback_mock, add_on_blocked_callback_mock, connect_mock): with mock.patch.object(ConstructibleConnection, '_adapter_connect_stream'): conn = ConstructibleConnection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) # Check conn.add_on_connection_blocked_callback.assert_called_once_with( conn._on_connection_blocked) conn.add_on_connection_unblocked_callback.assert_called_once_with( conn._on_connection_unblocked)
def test_blocked_connection_timeout_teminates_connection( self, connect_mock, add_timeout_mock, on_terminate_mock): conn = connection.Connection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) conn._on_connection_blocked( mock.Mock(name='frame.Method(Connection.Blocked)')) conn._on_blocked_connection_timeout() # Check conn._on_terminate.assert_called_once_with( connection.InternalCloseReasons.BLOCKED_CONNECTION_TIMEOUT, 'Blocked connection timeout expired') self.assertIsNone(conn._blocked_conn_timer)
def establish_connection(self): """Establish connection to the AMQP broker.""" conninfo = self.client if not conninfo.hostname: raise KeyError("Missing hostname for AMQP connection.") if conninfo.userid is None: raise KeyError("Missing user id for AMQP connection.") if conninfo.password is None: raise KeyError("Missing password for AMQP connection.") if not conninfo.port: conninfo.port = self.default_port credentials = connection.PlainCredentials(conninfo.userid, conninfo.password) return self.Connection( connection.ConnectionParameters(conninfo.hostname, port=conninfo.port, virtual_host=conninfo.virtual_host, credentials=credentials))
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 test_blocked_connection_on_terminate_removes_timer( self, adapter_disconnect_mock, connect_mock, add_timeout_mock, remove_timeout_mock): conn = connection.Connection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) conn._on_connection_blocked( mock.Mock(name='frame.Method(Connection.Blocked)')) self.assertIsNotNone(conn._blocked_conn_timer) timer = conn._blocked_conn_timer conn._on_terminate(0, 'test_on_terminate_removes_timer') # Check conn.remove_timeout.assert_called_once_with(timer) self.assertIsNone(conn._blocked_conn_timer)
def test_blocked_connection_unblocked_removes_timer( self, connect_mock, call_later_mock, remove_timeout_mock): with mock.patch.object(ConstructibleConnection, '_adapter_connect_stream'): conn = ConstructibleConnection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60)) conn._on_connection_blocked( conn, mock.Mock(name='frame.Method(Connection.Blocked)')) self.assertIsNotNone(conn._blocked_conn_timer) timer = conn._blocked_conn_timer conn._on_connection_unblocked( conn, mock.Mock(name='frame.Method(Connection.Unblocked)')) # Check conn._adapter_remove_timeout.assert_called_once_with(timer) self.assertIsNone(conn._blocked_conn_timer)
def test_blocked_connection_on_stream_terminated_removes_timer( self, adapter_disconnect_mock, connect_mock, add_timeout_mock, remove_timeout_mock): with mock.patch.object(ConstructibleConnection, '_adapter_connect_stream'): conn = ConstructibleConnection( parameters=connection.ConnectionParameters( blocked_connection_timeout=60), on_open_error_callback=lambda *args: None) conn._on_connection_blocked( conn, mock.Mock(name='frame.Method(Connection.Blocked)')) self.assertIsNotNone(conn._blocked_conn_timer) timer = conn._blocked_conn_timer conn._on_stream_terminated(exceptions.StreamLostError()) # Check conn._adapter_remove_timeout.assert_called_once_with(timer) self.assertIsNone(conn._blocked_conn_timer)
def test_explicit_ssl_with_default_port(self): params = connection.ConnectionParameters(ssl=True) self.assertEqual(params.ssl, True) self.assertEqual(params.port, params.DEFAULT_SSL_PORT)
def test_explicit_non_ssl_with_explict_port(self): params = connection.ConnectionParameters(ssl=False, port=100) self.assertEqual(params.ssl, False) self.assertEqual(params.port, 100)
def test_explicit_ssl_with_explict_port(self): params = connection.ConnectionParameters(ssl=True, port=99) self.assertEqual(params.ssl, True) self.assertEqual(params.port, 99)
def test_exlicit_none_socket_timeout(self): params = connection.ConnectionParameters(socket_timeout=None) self.assertIsNone(params.socket_timeout)
def test_explicit_non_ssl_with_explict_port(self): params = connection.ConnectionParameters(ssl_options=None, port=100) self.assertIsNone(params.ssl_options) self.assertEqual(params.port, 100)
def test_explicit_non_ssl_with_default_port(self): params = connection.ConnectionParameters(ssl_options=None) self.assertIsNone(params.ssl_options) self.assertEqual(params.port, params.DEFAULT_PORT)
def test_default_property_values(self): self.assert_default_parameter_values(connection.ConnectionParameters())