| #!/usr/bin/python |
| |
| __author__ = """Ashwin Ganti (aganti@google.com)""" |
| |
| import os, sys, socket, errno, unittest, threading |
| from time import time, sleep |
| import common |
| from autotest_lib.client.common_lib import error, barrier, base_barrier |
| from autotest_lib.client.common_lib.test_utils import mock |
| |
| |
| class listen_server_test(unittest.TestCase): |
| |
| def test_init(self): |
| server = barrier.listen_server() |
| server.close() |
| |
| |
| def test_close(self): |
| server = barrier.listen_server() |
| # cannot bind on the same port again |
| self.assertRaises(socket.error, barrier.listen_server) |
| server.close() |
| # now we can |
| server = barrier.listen_server() |
| server.close() |
| |
| |
| class barrier_test(unittest.TestCase): |
| |
| def setUp(self): |
| self.god = mock.mock_god() |
| self.god.mock_io() |
| |
| |
| def tearDown(self): |
| self.god.unmock_io() |
| |
| |
| def test_initialize(self): |
| b = barrier.barrier('127.0.0.1#', 'testtag', 100, 11921) |
| self.assertEqual(b._hostid, '127.0.0.1#') |
| self.assertEqual(b._tag, 'testtag') |
| self.assertEqual(b._timeout_secs, 100) |
| self.assertEqual(b._port, 11921) |
| |
| |
| def test__get_host_from_id(self): |
| hostname = base_barrier._get_host_from_id('my_host') |
| self.assertEqual(hostname, 'my_host') |
| |
| hostname = base_barrier._get_host_from_id('my_host#') |
| self.assertEqual(hostname, 'my_host') |
| |
| self.assertRaises(error.BarrierError, |
| base_barrier._get_host_from_id, '#my_host') |
| |
| |
| def test_update_timeout(self): |
| b = barrier.barrier('127.0.0.1#', 'update', 100) |
| b._update_timeout(120) |
| self.assertEqual(b._timeout_secs, 120) |
| |
| |
| def test_remaining(self): |
| b = barrier.barrier('127.0.0.1#', 'remain', 100) |
| remain = b._remaining() |
| self.assertEqual(remain, 100) |
| |
| |
| def test_master_welcome_garbage(self): |
| b = barrier.barrier('127.0.0.1#', 'garbage', 100) |
| waiting_before = dict(b._waiting) |
| seen_before = b._seen |
| |
| sender, receiver = socket.socketpair() |
| try: |
| sender.send('GET /foobar?p=-1 HTTP/1.0\r\n\r\n') |
| # This should not raise an exception. |
| b._master_welcome((receiver, 'fakeaddr')) |
| |
| self.assertEqual(waiting_before, b._waiting) |
| self.assertEqual(seen_before, b._seen) |
| |
| sender, receiver = socket.socketpair() |
| sender.send('abcdefg\x00\x01\x02\n'*5) |
| # This should not raise an exception. |
| b._master_welcome((receiver, 'fakeaddr')) |
| |
| self.assertEqual(waiting_before, b._waiting) |
| self.assertEqual(seen_before, b._seen) |
| finally: |
| sender.close() |
| receiver.close() |
| |
| |
| def test_rendezvous_basic(self): |
| # Basic rendezvous testing |
| self.rendezvous_test(60, port=11920) |
| |
| |
| def test_rendezvous_timeout(self): |
| # The rendezvous should time out here and throw a |
| # BarrierError since we are specifying a timeout of 0 |
| self.assertRaises(error.BarrierError, |
| self.rendezvous_test, 0, port=11921) |
| |
| |
| def test_rendezvous_abort_ok(self): |
| # Test with abort flag set to not abort. |
| self.rendezvous_test(60, port=11920, |
| test_abort=True, abort=False) |
| |
| |
| def test_rendezvous_abort(self): |
| # The rendezvous should abort here and throw a |
| # BarrierError since we are asking to abort |
| self.assertRaises(error.BarrierError, |
| self.rendezvous_test, 0, port=11921, |
| test_abort=True, abort=True) |
| |
| |
| def test_rendezvous_servers_basic(self): |
| # The rendezvous should time out here and throw a |
| # BarrierError since we are specifying a timeout of 0 |
| self.rendezvous_test(60, port=11921, |
| rendezvous_servers=True) |
| |
| |
| def test_rendezvous_servers_timeout(self): |
| # The rendezvous should time out here and throw a |
| # BarrierError since we are specifying a timeout of 0 |
| self.assertRaises(error.BarrierError, |
| self.rendezvous_test, 0, port=11922, |
| rendezvous_servers=True) |
| |
| |
| def test_rendezvous_servers_abort_ok(self): |
| # Test with abort flag set to not abort. |
| self.rendezvous_test(60, port=11920, rendezvous_servers=True, |
| test_abort=True, abort=False) |
| |
| |
| def test_rendezvous_servers_abort(self): |
| # The rendezvous should abort here and throw a |
| # BarrierError since we are asking to abort |
| self.assertRaises(error.BarrierError, |
| self.rendezvous_test, 0, port=11922, |
| rendezvous_servers=True, |
| test_abort=True, abort=True) |
| |
| |
| # Internal utility function (not a unit test) |
| def rendezvous_test(self, timeout, port=11922, |
| rendezvous_servers=False, test_abort=False, |
| abort=False, listen_server=None): |
| if listen_server: |
| port = None |
| |
| def _rdv(addr): |
| b1 = barrier.barrier(addr, "test_meeting", timeout, port, |
| listen_server=listen_server) |
| if not rendezvous_servers: |
| if test_abort: |
| b1.rendezvous('127.0.0.1#0', '127.0.0.1#1', abort=abort) |
| else: |
| b1.rendezvous('127.0.0.1#0', '127.0.0.1#1') |
| else: |
| if test_abort: |
| b1.rendezvous_servers('127.0.0.1#0', '127.0.0.1#1', |
| abort=abort) |
| else: |
| b1.rendezvous_servers('127.0.0.1#0', '127.0.0.1#1') |
| |
| |
| def _thread_rdv(addr): |
| # We need to ignore the exception on one side. |
| try: |
| _rdv(addr) |
| except error.BarrierError: |
| pass |
| |
| client = threading.Thread(target=_thread_rdv, |
| args=('127.0.0.1#0',)) |
| client.start() |
| _rdv('127.0.0.1#1') |
| client.join() |
| |
| |
| def test_reusing_listen_server(self): |
| """ |
| Test that reusing the same listen server object works. |
| """ |
| server = barrier.listen_server() |
| self.rendezvous_test(10, listen_server=server) |
| self.rendezvous_test(10, listen_server=server) |
| self.rendezvous_test(10, listen_server=server) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |