/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/blackbox/test_serve.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_serve.py
20
20
import os
21
21
import signal
22
22
import sys
23
 
import thread
 
23
from _thread import interrupt_main
 
24
 
24
25
import threading
25
26
 
26
27
from ... import (
77
78
            finally:
78
79
                # Then stop the server
79
80
                trace.mutter('interrupting...')
80
 
                thread.interrupt_main()
 
81
                interrupt_main()
81
82
        # When the hook is fired, it just starts ``on_server_start_thread`` and
82
83
        # return
 
84
 
83
85
        def on_server_start(backing_urls, tcp_server):
84
86
            t = threading.Thread(
85
87
                target=on_server_start_thread, args=(tcp_server,))
88
90
        SmartTCPServer.hooks.install_named_hook(
89
91
            'server_started_ex', on_server_start,
90
92
            'run_bzr_serve_then_func hook')
91
 
        # It seesm thread.interrupt_main() will not raise KeyboardInterrupt
 
93
        # It seems interrupt_main() will not raise KeyboardInterrupt
92
94
        # until after socket.accept returns. So we set the timeout low to make
93
95
        # the test faster.
94
96
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
98
100
                                    retcode=retcode)
99
101
        except KeyboardInterrupt as e:
100
102
            return (self._last_cmd_stdout.getvalue(),
101
 
                self._last_cmd_stderr.getvalue())
 
103
                    self._last_cmd_stderr.getvalue())
102
104
        return out, err
103
105
 
104
106
 
116
118
        """
117
119
        def hook(exception):
118
120
            if exception[0] is KeyboardInterrupt:
119
 
                sys.stderr.write('catching KeyboardInterrupt\n')
 
121
                sys.stderr.write(b'catching KeyboardInterrupt\n')
120
122
                return True
121
123
            else:
122
124
                return False
140
142
        # Hide stdin from the subprocess module, so it won't fail to close it.
141
143
        process.stdin = None
142
144
        result = self.finish_bzr_subprocess(process)
143
 
        self.assertEqual('', result[0])
144
 
        self.assertEqual('', result[1])
 
145
        self.assertEqual(b'', result[0])
 
146
        self.assertEqual(b'', result[1])
145
147
 
146
148
    def assertServerFinishesCleanly(self, process):
147
149
        """Shutdown the brz serve instance process looking for errors."""
148
150
        # Shutdown the server
149
151
        result = self.finish_bzr_subprocess(process, retcode=3,
150
152
                                            send_signal=signal.SIGINT)
151
 
        self.assertEqual('', result[0])
152
 
        self.assertEqual('brz: interrupted\n', result[1])
 
153
        self.assertEqual(b'', result[0])
 
154
        self.assertEqual(b'brz: interrupted\n', result[1])
153
155
 
154
156
    def make_read_requests(self, branch):
155
157
        """Do some read only requests."""
192
194
        args.extend(extra_options)
193
195
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
194
196
        port_line = process.stderr.readline()
195
 
        prefix = 'listening on port: '
 
197
        prefix = b'listening on port: '
196
198
        self.assertStartsWith(port_line, prefix)
197
199
        port = int(port_line[len(prefix):])
198
200
        url = 'bzr://localhost:%d/' % port
267
269
        f = open(log_fname, 'rb')
268
270
        content = f.read()
269
271
        f.close()
270
 
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
272
        self.assertContainsRe(content, br'hpss request: \[[0-9-]+\]')
271
273
 
272
274
    def test_bzr_serve_supports_configurable_timeout(self):
273
275
        gs = config.GlobalStack()
275
277
        # Save the config as the subprocess will use it
276
278
        gs.store.save()
277
279
        process, url = self.start_server_port()
278
 
        self.build_tree_contents([('a_file', 'contents\n')])
 
280
        self.build_tree_contents([('a_file', b'contents\n')])
279
281
        # We can connect and issue a request
280
282
        t = transport.get_transport_from_url(url)
281
 
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
283
        self.assertEqual(b'contents\n', t.get_bytes('a_file'))
282
284
        # However, if we just wait for more content from the server, it will
283
285
        # eventually disconnect us.
284
286
        m = t.get_smart_medium()
286
288
        # Now, we wait for timeout to trigger
287
289
        err = process.stderr.readline()
288
290
        self.assertEqual(
289
 
            'Connection Timeout: disconnecting client after 0.2 seconds\n',
 
291
            b'Connection Timeout: disconnecting client after 0.2 seconds\n',
290
292
            err)
291
293
        self.assertServerFinishesCleanly(process)
292
294
 
293
295
    def test_bzr_serve_supports_client_timeout(self):
294
296
        process, url = self.start_server_port(['--client-timeout=0.1'])
295
 
        self.build_tree_contents([('a_file', 'contents\n')])
 
297
        self.build_tree_contents([('a_file', b'contents\n')])
296
298
        # We can connect and issue a request
297
299
        t = transport.get_transport_from_url(url)
298
 
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
300
        self.assertEqual(b'contents\n', t.get_bytes('a_file'))
299
301
        # However, if we just wait for more content from the server, it will
300
302
        # eventually disconnect us.
301
303
        # TODO: Use something like signal.alarm() so that if the server doesn't
306
308
        # Now, we wait for timeout to trigger
307
309
        err = process.stderr.readline()
308
310
        self.assertEqual(
309
 
            'Connection Timeout: disconnecting client after 0.1 seconds\n',
 
311
            b'Connection Timeout: disconnecting client after 0.1 seconds\n',
310
312
            err)
311
313
        self.assertServerFinishesCleanly(process)
312
314
 
313
315
    def test_bzr_serve_graceful_shutdown(self):
314
 
        big_contents = 'a'*64*1024
 
316
        big_contents = b'a' * 64 * 1024
315
317
        self.build_tree_contents([('bigfile', big_contents)])
316
318
        process, url = self.start_server_port(['--client-timeout=1.0'])
317
319
        t = transport.get_transport_from_url(url)
318
320
        m = t.get_smart_medium()
319
321
        c = client._SmartClient(m)
320
322
        # Start, but don't finish a response
321
 
        resp, response_handler = c.call_expecting_body('get', 'bigfile')
322
 
        self.assertEqual(('ok',), resp)
 
323
        resp, response_handler = c.call_expecting_body(b'get', b'bigfile')
 
324
        self.assertEqual((b'ok',), resp)
323
325
        # Note: process.send_signal is a Python 2.6ism
324
326
        process.send_signal(signal.SIGHUP)
325
327
        # Wait for the server to notice the signal, and then read the actual
326
328
        # body of the response. That way we know that it is waiting for the
327
329
        # request to finish
328
 
        self.assertEqual('Requested to stop gracefully\n',
329
 
                         process.stderr.readline())
330
 
        self.assertEqual('Waiting for 1 client(s) to finish\n',
331
 
                         process.stderr.readline())
 
330
        self.assertEqual(b'Requested to stop gracefully\n',
 
331
                         process.stderr.readline())
 
332
        self.assertIn(process.stderr.readline(),
 
333
                      (b'', b'Waiting for 1 client(s) to finish\n'))
332
334
        body = response_handler.read_body_bytes()
333
335
        if body != big_contents:
334
336
            self.fail('Failed to properly read the contents of "bigfile"')
335
337
        # Now that our request is finished, the medium should notice it has
336
338
        # been disconnected.
337
 
        self.assertEqual('', m.read_bytes(1))
 
339
        self.assertEqual(b'', m.read_bytes(1))
338
340
        # And the server should be stopping
339
341
        self.assertEqual(0, process.wait())
340
342
 
358
360
        # The when_server_started method issued a find_repositoryV3 that should
359
361
        # fail with 'norepository' because there are no repositories inside the
360
362
        # --directory.
361
 
        self.assertEqual(('norepository',), self.client_resp)
 
363
        self.assertEqual((b'norepository',), self.client_resp)
362
364
 
363
365
    def when_server_started(self):
364
366
        # Connect to the TCP server and issue some requests and see what comes
398
400
        bzr_server = BzrServerFactory(
399
401
            self.fake_expanduser, lambda t: base_path)
400
402
        mem_transport = self.get_transport()
401
 
        mem_transport.mkdir_multi(['home', 'home/user'])
 
403
        mem_transport.mkdir('home')
 
404
        mem_transport.mkdir('home/user')
402
405
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
403
406
        self.addCleanup(bzr_server.tear_down)
404
407
        return bzr_server
409
412
 
410
413
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
411
414
        bzr_server = self.make_test_server('/foo')
412
 
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
415
        self.assertFalse(
 
416
            bzr_server.smart_server.backing_transport.has('~user'))
413
417
 
414
418
    def test_get_base_path(self):
415
419
        """cmd_serve will turn the --directory option into a LocalTransport
421
425
        base_url = urlutils.local_path_to_url(base_dir) + '/'
422
426
        # Define a fake 'protocol' to capture the transport that cmd_serve
423
427
        # passes to serve_bzr.
 
428
 
424
429
        def capture_transport(transport, host, port, inet, timeout):
425
430
            self.bzr_serve_transport = transport
426
431
        cmd = builtins.cmd_serve()
433
438
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
434
439
        # Read-write
435
440
        cmd.run(directory=base_dir, protocol=capture_transport,
436
 
            allow_writes=True)
 
441
                allow_writes=True)
437
442
        server_maker = BzrServerFactory()
438
443
        self.assertEqual(base_url, self.bzr_serve_transport.base)
439
444
        self.assertEqual(base_dir,
440
 
            server_maker.get_base_path(self.bzr_serve_transport))
 
445
                         server_maker.get_base_path(self.bzr_serve_transport))
441
446
        # Read-only, from a URL
442
447
        cmd.run(directory=base_url, protocol=capture_transport)
443
448
        server_maker = BzrServerFactory()