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