def test_heartbeat_interval(self):
heartbeat = Heartbeat(60, fake_function)
self.assertEqual(heartbeat._interval, 60)
self.assertEqual(heartbeat._threshold, 0)
heartbeat = Heartbeat(360, fake_function)
self.assertEqual(heartbeat._interval, 360)
self.assertEqual(heartbeat._threshold, 0)
def test_heartbeat_no_interval(self):
heartbeat = Heartbeat(0, fake_function)
self.assertEqual(heartbeat._interval, 0)
self.assertEqual(heartbeat._threshold, 0)
self.assertFalse(heartbeat.start([]))
heartbeat = Heartbeat(None, fake_function)
self.assertEqual(heartbeat._interval, None)
self.assertEqual(heartbeat._threshold, 0)
self.assertFalse(heartbeat.start([]))
def test_heartbeat_register_reads(self):
heartbeat = Heartbeat(60, fake_function)
time.sleep(0.01)
for _ in range(100):
heartbeat.register_read()
self.assertEqual(heartbeat._reads_since_check, 100)
def test_heartbeat_register_heartbeat(self):
heartbeat = Heartbeat(1)
heartbeat.start([])
last_heartbeat = heartbeat._last_heartbeat
time.sleep(0.01)
heartbeat.register_heartbeat()
self.assertNotEqual(heartbeat._last_heartbeat, last_heartbeat)
def __init__(self, hostname, username, password, port=5672, **kwargs):
"""
:param str hostname: Hostname
:param str username: Username
:param str password: Password
:param int port: Server port
:param str virtual_host: Virtualhost
:param int heartbeat: RabbitMQ Heartbeat interval
:param int|float timeout: Socket timeout
:param bool ssl: Enable SSL
:param dict ssl_options: SSL kwargs (from ssl.wrap_socket)
:param bool lazy: Lazy initialize the connection
:return:
"""
super(Connection, self).__init__()
self.parameters = {
'hostname': hostname,
'username': username,
'password': password,
'port': port,
'virtual_host': kwargs.get('virtual_host', '/'),
'heartbeat': kwargs.get('heartbeat', 60),
'timeout': kwargs.get('timeout', 30),
'ssl': kwargs.get('ssl', False),
'ssl_options': kwargs.get('ssl_options', {})
}
self._validate_parameters()
self.heartbeat = Heartbeat(self.parameters['heartbeat'])
self._io = IO(self.parameters, on_read=self._read_buffer)
self._channel0 = Channel0(self)
self._channels = {}
if not kwargs.get('lazy', False):
self.open()
def test_heartbeat_extended_loop(self):
self.beats = 0
def send_heartbeat():
self.beats += 1
heartbeat = Heartbeat(60, send_heartbeat=send_heartbeat)
heartbeat._running.set()
heartbeat.register_read()
# Miss one write/
self.assertTrue(heartbeat._check_for_life_signs())
for _ in range(1000):
heartbeat.register_read()
heartbeat.register_write()
self.assertFalse(heartbeat._threshold)
self.assertTrue(heartbeat._check_for_life_signs())
heartbeat.register_write()
# Miss one read.
self.assertTrue(heartbeat._check_for_life_signs())
self.assertEqual(heartbeat._threshold, 1)
self.assertEqual(self.beats, 1)
heartbeat.register_read()
heartbeat.register_write()
self.assertTrue(heartbeat._check_for_life_signs())
self.assertEqual(heartbeat._threshold, 0)
heartbeat.stop()
def __init__(self, hostname, username, password, port=5672, **kwargs):
super(Connection, self).__init__()
self.parameters = {
'hostname': hostname,
'username': username,
'password': password,
'port': port,
'virtual_host': kwargs.get('virtual_host', DEFAULT_VIRTUAL_HOST),
'heartbeat': kwargs.get('heartbeat', DEFAULT_HEARTBEAT_INTERVAL),
'timeout': kwargs.get('timeout', DEFAULT_SOCKET_TIMEOUT),
'ssl': kwargs.get('ssl', False),
'ssl_options': kwargs.get('ssl_options', {}),
'client_properties': kwargs.get('client_properties', {})
}
self._validate_parameters()
self._io = IO(self.parameters,
exceptions=self._exceptions,
on_read_impl=self._read_buffer)
self._channel0 = Channel0(self, self.parameters['client_properties'])
self._channels = {}
self._last_channel_id = None
self.heartbeat = Heartbeat(self.parameters['heartbeat'],
self._channel0.send_heartbeat)
if not kwargs.get('lazy', False):
self.open()
def test_heartbeat_register_writes(self):
heartbeat = Heartbeat(60, fake_function)
time.sleep(0.01)
for _ in range(32):
heartbeat.register_write()
self.assertEqual(heartbeat._writes_since_check, 32)
def test_heartbeat_raise_exception(self):
heartbeat = Heartbeat(60, None)
self.assertRaisesRegexp(
AMQPConnectionError,
'Connection dead, no heartbeat or data received in >= 120s',
heartbeat._raise_or_append_exception
)
heartbeat = Heartbeat(120, None)
self.assertRaisesRegexp(
AMQPConnectionError,
'Connection dead, no heartbeat or data received in >= 240',
heartbeat._raise_or_append_exception
)
def test_heartbeat_do_not_start_new_timer_when_stopped(self):
heartbeat = Heartbeat(60, fake_function)
self.assertIsNone(heartbeat._timer)
heartbeat._start_new_timer()
self.assertIsNone(heartbeat._timer)
def test_heartbeat_basic_raise_on_missed_heartbeats(self):
heartbeat = Heartbeat(0.01, fake_function)
exceptions = []
heartbeat.start(exceptions)
time.sleep(0.1)
self.assertGreater(len(heartbeat._exceptions), 0)
heartbeat.stop()
def test_heartbeat_raise_when_check_for_life_when_exceptions_not_set(self):
heartbeat = Heartbeat(1)
heartbeat._beats_since_check = 0
heartbeat._last_heartbeat = time.time() - 100
# Normally the exception should be passed down to the list of
# exceptions in the connection, but if that list for some obscure
# reason is None, we should raise directly in _check_for_life_signs.
self.assertRaises(AMQPConnectionError, heartbeat._check_for_life_signs)
def test_heartbeat_disabled(self):
heartbeat = Heartbeat(0, fake_function)
self.assertFalse(heartbeat._running.is_set())
heartbeat.start([])
self.assertFalse(heartbeat._running.is_set())
self.assertIsNone(heartbeat._timer)
def test_heartbeat_start(self):
heartbeat = Heartbeat(60, fake_function)
self.assertFalse(heartbeat._running.is_set())
heartbeat.start([])
self.assertTrue(heartbeat._running.is_set())
self.assertIsNotNone(heartbeat._timer)
heartbeat.stop()
def test_heartbeat_raise_when_check_for_life_when_exceptions_not_set(self):
heartbeat = Heartbeat(60, fake_function)
heartbeat._running.set()
heartbeat._reads_since_check = 0
heartbeat._threshold = 3
heartbeat.register_write()
# Normally the exception should be passed down to the list of
# exceptions in the connection, but if that list for some obscure
# reason is None, we should raise directly in _check_for_life_signs.
self.assertRaises(AMQPConnectionError, heartbeat._check_for_life_signs)
def test_heartbeat_raise_after_threshold(self):
heartbeat = Heartbeat(60, fake_function)
exceptions = []
heartbeat.start(exceptions)
heartbeat.register_write()
self.assertTrue(heartbeat._check_for_life_signs())
heartbeat.register_write()
self.assertFalse(heartbeat._check_for_life_signs())
self.assertTrue(exceptions)
heartbeat.stop()
def test_heartbeat_threshold_reset(self):
heartbeat = Heartbeat(60, fake_function)
heartbeat._running.set()
heartbeat.register_write()
self.assertEqual(heartbeat._threshold, 0)
self.assertTrue(heartbeat._check_for_life_signs())
self.assertEqual(heartbeat._threshold, 1)
heartbeat.register_write()
heartbeat.register_read()
self.assertTrue(heartbeat._check_for_life_signs())
self.assertEqual(heartbeat._threshold, 0)
def test_heartbeat_running_cleared_after_raise(self):
heartbeat = Heartbeat(60, fake_function)
exceptions = []
self.assertTrue(heartbeat.start(exceptions))
self.assertTrue(heartbeat._running.is_set())
heartbeat.register_write()
heartbeat._check_for_life_signs()
heartbeat.register_write()
heartbeat._check_for_life_signs()
self.assertFalse(heartbeat._running.is_set())
heartbeat.stop()
def test_heartbeat_send_heartbeat(self):
self.beats = 0
def send_heartbeat():
self.beats += 1
heartbeat = Heartbeat(60, send_heartbeat=send_heartbeat)
heartbeat._running.set()
for _ in range(10):
heartbeat.register_read()
self.assertTrue(heartbeat._check_for_life_signs())
self.assertEqual(self.beats, 10)
heartbeat.stop()
def __init__(self, hostname, username, password, port=5672, **kwargs):
"""
:param str hostname: Hostname
:param str username: Username
:param str password: Password
:param int port: Server port
:param str virtual_host: Virtual host
:param int heartbeat: RabbitMQ Heartbeat interval
:param int|float timeout: Socket timeout
:param bool ssl: Enable SSL
:param dict ssl_options: SSL kwargs (from ssl.wrap_socket)
:param dict client_properties: None or dict of client properties
:param bool lazy: Lazy initialize the connection
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:return:
"""
super(Connection, self).__init__()
self.parameters = {
'hostname': hostname,
'username': username,
'password': password,
'port': port,
'virtual_host': kwargs.get('virtual_host', DEFAULT_VIRTUAL_HOST),
'heartbeat': kwargs.get('heartbeat', DEFAULT_HEARTBEAT_INTERVAL),
'timeout': kwargs.get('timeout', DEFAULT_SOCKET_TIMEOUT),
'ssl': kwargs.get('ssl', False),
'ssl_options': kwargs.get('ssl_options', {}),
'client_properties': kwargs.get('client_properties', {})
}
self._validate_parameters()
self._io = IO(self.parameters,
exceptions=self._exceptions,
on_read_impl=self._read_buffer)
self._channel0 = Channel0(self, self.parameters['client_properties'])
self._channels = {}
self._last_channel_id = None
self.heartbeat = Heartbeat(self.parameters['heartbeat'],
self._channel0.send_heartbeat)
if not kwargs.get('lazy', False):
self.open()
def test_heartbeat_append_exception(self):
heartbeat = Heartbeat(60, None)
heartbeat._exceptions = []
def check(exception):
heartbeat._raise_or_append_exception()
if exception:
raise exception.pop()
self.assertRaisesRegexp(
AMQPConnectionError,
'Connection dead, no heartbeat or data received in >= 120s',
check, heartbeat._exceptions
)
heartbeat._interval = 120
self.assertRaisesRegexp(
AMQPConnectionError,
'Connection dead, no heartbeat or data received in >= 240',
check, heartbeat._exceptions
)
def test_heartbeat_interval(self):
heartbeat = Heartbeat(60)
self.assertEqual(heartbeat._interval, 61)
self.assertEqual(heartbeat._threshold, 122)
def test_heartbeat_do_not_execute_life_signs_when_stopped(self):
heartbeat = Heartbeat(60)
heartbeat._stopped.set()
self.assertFalse(heartbeat._check_for_life_signs())
def test_heartbeat_do_not_execute_life_signs_when_stopped(self):
heartbeat = Heartbeat(60, fake_function)
self.assertFalse(heartbeat._check_for_life_signs())
def test_heartbeat_minimum_interval(self):
heartbeat = Heartbeat(0.1)
self.assertEqual(heartbeat._interval, 2)
self.assertEqual(heartbeat._threshold, 4)
def test_heartbeat_stop(self):
heartbeat = Heartbeat(1)
heartbeat.start([])
heartbeat.stop()
self.assertIsNone(heartbeat._timer)
def test_heartbeat_register_beat(self):
heartbeat = Heartbeat(1)
heartbeat.start([])
self.assertEqual(heartbeat._beats_since_check, 0)
heartbeat.register_beat()
self.assertEqual(heartbeat._beats_since_check, 1)
def test_heartbeat_basic_raise_on_missed_heartbeats(self):
exceptions = []
heartbeat = Heartbeat(1)
heartbeat.start(exceptions)
time.sleep(6)
self.assertGreater(len(heartbeat._exceptions), 0)
