/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-05-06 11:48:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180506114854-h4qd9ojaqy8wxjsd
Move .mailmap to root.

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