/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: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

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