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)