Debian Codegraph @

src/tests/portserver_test.py

raw
1 #!/usr/bin/python3
2 #
3 # Copyright 2015 Google Inc. All Rights Reserved.
4 #
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
8 #
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16 #
17 """Tests for the example portserver."""
18
19 import asyncio
20 import os
21 import signal
22 import socket
23 import subprocess
24 import sys
25 import time
26 import unittest
27 from unittest import mock
28 from multiprocessing import Process
29
30 import portpicker
31
32 # On Windows, portserver.py is located in the "Scripts" folder, which isn't
33 # added to the import path by default
34 if sys.platform == 'win32':
35 sys.path.append(os.path.join(os.path.split(sys.executable)[0]))
36
37 try:
38 import portserver
39 except ImportError:
40 # Or if testing from a third_party/py/portpicker/ style installed
41 # package tree find it this way.
42 from portpicker import portserver
43
44
45 def setUpModule():
46 portserver._configure_logging(verbose=True)
47
48 def exit_immediately():
49 os._exit(0)
50
51 class PortserverFunctionsTest(unittest.TestCase):
52
53 @classmethod
54 def setUp(cls):
55 cls.port = portpicker.PickUnusedPort()
56
57 def test_get_process_command_line(self):
58 portserver._get_process_command_line(os.getpid())
59
60 def test_get_process_start_time(self):
61 self.assertGreater(portserver._get_process_start_time(os.getpid()), 0)
62
63 def test_is_port_free(self):
64 """This might be flaky unless this test is run with a portserver."""
65 # The port should be free initially.
66 self.assertTrue(portserver._is_port_free(self.port))
67
68 cases = [
69 (socket.AF_INET, socket.SOCK_STREAM, None),
70 (socket.AF_INET6, socket.SOCK_STREAM, 1),
71 (socket.AF_INET, socket.SOCK_DGRAM, None),
72 (socket.AF_INET6, socket.SOCK_DGRAM, 1),
73 ]
74
75 # Using v6only=0 on Windows doesn't result in collisions
76 if sys.platform != 'win32':
77 cases.extend([
78 (socket.AF_INET6, socket.SOCK_STREAM, 0),
79 (socket.AF_INET6, socket.SOCK_DGRAM, 0),
80 ])
81
82 for (sock_family, sock_type, v6only) in cases:
83 # Occupy the port on a subset of possible protocols.
84 try:
85 sock = socket.socket(sock_family, sock_type, 0)
86 except socket.error:
87 print('Kernel does not support sock_family=%d' % sock_family,
88 file=sys.stderr)
89 # Skip this case, since we cannot occupy a port.
90 continue
91
92 if not hasattr(socket, 'IPPROTO_IPV6'):
93 v6only = None
94
95 if v6only is not None:
96 try:
97 sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY,
98 v6only)
99 except socket.error:
100 print('Kernel does not support IPV6_V6ONLY=%d' % v6only,
101 file=sys.stderr)
102 # Don't care; just proceed with the default.
103 sock.bind(('', self.port))
104
105 # The port should be busy.
106 self.assertFalse(portserver._is_port_free(self.port))
107 sock.close()
108
109 # Now it's free again.
110 self.assertTrue(portserver._is_port_free(self.port))
111
112 def test_is_port_free_exception(self):
113 with mock.patch.object(socket, 'socket') as mock_sock:
114 mock_sock.side_effect = socket.error('fake socket error', 0)
115 self.assertFalse(portserver._is_port_free(self.port))
116
117 def test_should_allocate_port(self):
118 self.assertFalse(portserver._should_allocate_port(0))
119 self.assertFalse(portserver._should_allocate_port(1))
120 self.assertTrue(portserver._should_allocate_port, os.getpid())
121
122 p = Process(target=exit_immediately)
123 p.start()
124 child_pid = p.pid
125 p.join()
126
127 # This test assumes that after waitpid returns the kernel has finished
128 # cleaning the process. We also assume that the kernel will not reuse
129 # the former child's pid before our next call checks for its existence.
130 # Likely assumptions, but not guaranteed.
131 self.assertFalse(portserver._should_allocate_port(child_pid))
132
133 def test_parse_command_line(self):
134 with mock.patch.object(
135 sys, 'argv', ['program_name', '--verbose',
136 '--portserver_static_pool=1-1,3-8',
137 '--portserver_unix_socket_address=@hello-test']):
138 portserver._parse_command_line()
139
140 def test_parse_port_ranges(self):
141 self.assertFalse(portserver._parse_port_ranges(''))
142 self.assertCountEqual(portserver._parse_port_ranges('1-1'), {1})
143 self.assertCountEqual(portserver._parse_port_ranges('1-1,3-8,375-378'),
144 {1, 3, 4, 5, 6, 7, 8, 375, 376, 377, 378})
145 # Unparsable parts are logged but ignored.
146 self.assertEqual({1, 2},
147 portserver._parse_port_ranges('1-2,not,numbers'))
148 self.assertEqual(set(), portserver._parse_port_ranges('8080-8081x'))
149 # Port ranges that go out of bounds are logged but ignored.
150 self.assertEqual(set(), portserver._parse_port_ranges('0-1138'))
151 self.assertEqual(set(range(19, 84 + 1)),
152 portserver._parse_port_ranges('1138-65536,19-84'))
153
154 def test_configure_logging(self):
155 """Just code coverage really."""
156 portserver._configure_logging(False)
157 portserver._configure_logging(True)
158
159
160 _test_socket_addr = f'@TST-{os.getpid()}'
161
162 @mock.patch.object(
163 sys, 'argv', ['PortserverFunctionsTest.test_main',
164 f'--portserver_unix_socket_address={_test_socket_addr}']
165 )
166 @mock.patch.object(portserver, '_parse_port_ranges')
167 def test_main_no_ports(self, *unused_mocks):
168 portserver._parse_port_ranges.return_value = set()
169 with self.assertRaises(SystemExit):
170 portserver.main()
171
172 @unittest.skipUnless(sys.executable, 'Requires a stand alone interpreter')
173 @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'AF_UNIX required')
174 def test_portserver_binary(self):
175 """Launch python portserver.py and test it."""
176 # Blindly assuming tree layout is src/tests/portserver_test.py
177 # with src/portserver.py.
178 portserver_py = os.path.join(
179 os.path.dirname(os.path.dirname(__file__)),
180 'portserver.py')
181 anon_addr = self._test_socket_addr.replace('@', '\0')
182
183 conn = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
184 with self.assertRaises(
185 ConnectionRefusedError,
186 msg=f'{self._test_socket_addr} should not listen yet.'):
187 conn.connect(anon_addr)
188 conn.close()
189
190 server = subprocess.Popen(
191 [sys.executable, portserver_py,
192 f'--portserver_unix_socket_address={self._test_socket_addr}'],
193 stderr=subprocess.PIPE,
194 )
195 try:
196 # Wait a few seconds for the server to start listening.
197 start_time = time.monotonic()
198 while True:
199 time.sleep(0.05)
200 try:
201 conn.connect(anon_addr)
202 conn.close()
203 except ConnectionRefusedError:
204 delta = time.monotonic() - start_time
205 if delta < 4:
206 continue
207 else:
208 server.kill()
209 self.fail('Failed to connect to portserver '
210 f'{self._test_socket_addr} within '
211 f'{delta} seconds. STDERR:\n' +
212 server.stderr.read().decode('utf-8'))
213 else:
214 break
215
216 ports = set()
217 port = portpicker.get_port_from_port_server(
218 portserver_address=self._test_socket_addr)
219 ports.add(port)
220 port = portpicker.get_port_from_port_server(
221 portserver_address=self._test_socket_addr)
222 ports.add(port)
223
224 with subprocess.Popen('exit 0', shell=True) as quick_process:
225 quick_process.wait()
226 # This process doesn't exist so it should be a denied alloc.
227 # We use the pid from the above quick_process under the assumption
228 # that most OSes try to avoid rapid pid recycling.
229 denied_port = portpicker.get_port_from_port_server(
230 portserver_address=self._test_socket_addr,
231 pid=quick_process.pid) # A now unused pid.
232 self.assertIsNone(denied_port)
233
234 self.assertEqual(len(ports), 2, msg=ports)
235
236 # Check statistics from portserver
237 server.send_signal(signal.SIGUSR1)
238 # TODO implement an I/O timeout
239 for line in server.stderr:
240 if b'denied-allocations ' in line:
241 denied_allocations = int(
242 line.split(b'denied-allocations ', 2)[1])
243 self.assertEqual(1, denied_allocations, msg=line)
244 elif b'total-allocations ' in line:
245 total_allocations = int(
246 line.split(b'total-allocations ', 2)[1])
247 self.assertEqual(2, total_allocations, msg=line)
248 break
249
250 rejected_port = portpicker.get_port_from_port_server(
251 portserver_address=self._test_socket_addr,
252 pid=99999999999999999999999999999999999) # Out of range.
253 self.assertIsNone(rejected_port)
254
255 # Done. shutdown gracefully.
256 server.send_signal(signal.SIGINT)
257 server.communicate(timeout=2)
258 finally:
259 server.kill()
260 server.wait()
261
262
263 class PortPoolTest(unittest.TestCase):
264
265 @classmethod
266 def setUpClass(cls):
267 cls.port = portpicker.PickUnusedPort()
268
269 def setUp(self):
270 self.pool = portserver._PortPool()
271
272 def test_initialization(self):
273 self.assertEqual(0, self.pool.num_ports())
274 self.pool.add_port_to_free_pool(self.port)
275 self.assertEqual(1, self.pool.num_ports())
276 self.pool.add_port_to_free_pool(1138)
277 self.assertEqual(2, self.pool.num_ports())
278 self.assertRaises(ValueError, self.pool.add_port_to_free_pool, 0)
279 self.assertRaises(ValueError, self.pool.add_port_to_free_pool, 65536)
280
281 @mock.patch.object(portserver, '_is_port_free')
282 def test_get_port_for_process_ok(self, mock_is_port_free):
283 self.pool.add_port_to_free_pool(self.port)
284 mock_is_port_free.return_value = True
285 self.assertEqual(self.port, self.pool.get_port_for_process(os.getpid()))
286 self.assertEqual(1, self.pool.ports_checked_for_last_request)
287
288 @mock.patch.object(portserver, '_is_port_free')
289 def test_get_port_for_process_none_left(self, mock_is_port_free):
290 self.pool.add_port_to_free_pool(self.port)
291 self.pool.add_port_to_free_pool(22)
292 mock_is_port_free.return_value = False
293 self.assertEqual(2, self.pool.num_ports())
294 self.assertEqual(0, self.pool.get_port_for_process(os.getpid()))
295 self.assertEqual(2, self.pool.num_ports())
296 self.assertEqual(2, self.pool.ports_checked_for_last_request)
297
298 @mock.patch.object(portserver, '_is_port_free')
299 @mock.patch.object(os, 'getpid')
300 def test_get_port_for_process_pid_eq_port(self, mock_getpid, mock_is_port_free):
301 self.pool.add_port_to_free_pool(12345)
302 self.pool.add_port_to_free_pool(12344)
303 mock_is_port_free.side_effect = lambda port: port == os.getpid()
304 mock_getpid.return_value = 12345
305 self.assertEqual(2, self.pool.num_ports())
306 self.assertEqual(12345, self.pool.get_port_for_process(os.getpid()))
307 self.assertEqual(2, self.pool.ports_checked_for_last_request)
308
309 @mock.patch.object(portserver, '_is_port_free')
310 @mock.patch.object(os, 'getpid')
311 def test_get_port_for_process_pid_ne_port(self, mock_getpid, mock_is_port_free):
312 self.pool.add_port_to_free_pool(12344)
313 self.pool.add_port_to_free_pool(12345)
314 mock_is_port_free.side_effect = lambda port: port != os.getpid()
315 mock_getpid.return_value = 12345
316 self.assertEqual(2, self.pool.num_ports())
317 self.assertEqual(12344, self.pool.get_port_for_process(os.getpid()))
318 self.assertEqual(2, self.pool.ports_checked_for_last_request)
319
320
321 @mock.patch.object(portserver, '_get_process_command_line')
322 @mock.patch.object(portserver, '_should_allocate_port')
323 @mock.patch.object(portserver._PortPool, 'get_port_for_process')
324 class PortServerRequestHandlerTest(unittest.TestCase):
325 def setUp(self):
326 portserver._configure_logging(verbose=True)
327 self.rh = portserver._PortServerRequestHandler([23, 42, 54])
328
329 def test_stats_reporting(self, *unused_mocks):
330 with mock.patch.object(portserver, 'log') as mock_logger:
331 self.rh.dump_stats()
332 mock_logger.info.assert_called_with('total-allocations 0')
333
334 def test_handle_port_request_bad_data(self, *unused_mocks):
335 self._test_bad_data_from_client(b'')
336 self._test_bad_data_from_client(b'\n')
337 self._test_bad_data_from_client(b'99Z\n')
338 self._test_bad_data_from_client(b'99 8\n')
339 self.assertEqual([], portserver._get_process_command_line.mock_calls)
340
341 def _test_bad_data_from_client(self, data):
342 mock_writer = mock.Mock(asyncio.StreamWriter)
343 self.rh._handle_port_request(data, mock_writer)
344 self.assertFalse(portserver._should_allocate_port.mock_calls)
345
346 def test_handle_port_request_denied_allocation(self, *unused_mocks):
347 portserver._should_allocate_port.return_value = False
348 self.assertEqual(0, self.rh._denied_allocations)
349 mock_writer = mock.Mock(asyncio.StreamWriter)
350 self.rh._handle_port_request(b'5\n', mock_writer)
351 self.assertEqual(1, self.rh._denied_allocations)
352
353 def test_handle_port_request_bad_port_returned(self, *unused_mocks):
354 portserver._should_allocate_port.return_value = True
355 self.rh._port_pool.get_port_for_process.return_value = 0
356 mock_writer = mock.Mock(asyncio.StreamWriter)
357 self.rh._handle_port_request(b'6\n', mock_writer)
358 self.rh._port_pool.get_port_for_process.assert_called_once_with(6)
359 self.assertEqual(1, self.rh._denied_allocations)
360
361 def test_handle_port_request_success(self, *unused_mocks):
362 portserver._should_allocate_port.return_value = True
363 self.rh._port_pool.get_port_for_process.return_value = 999
364 mock_writer = mock.Mock(asyncio.StreamWriter)
365 self.assertEqual(0, self.rh._total_allocations)
366 self.rh._handle_port_request(b'8', mock_writer)
367 portserver._should_allocate_port.assert_called_once_with(8)
368 self.rh._port_pool.get_port_for_process.assert_called_once_with(8)
369 self.assertEqual(1, self.rh._total_allocations)
370 self.assertEqual(0, self.rh._denied_allocations)
371 mock_writer.write.assert_called_once_with(b'999\n')
372
373
374 if __name__ == '__main__':
375 unittest.main()