← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2012-02-20 12:19:29 UTC
  • mfrom: (6437.23.11 2.5)
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: jelmer@samba.org-20120220121929-7ni2psvjoatm1yp4
Merge bzr/2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
25
25
 
26
26
from bzrlib import (
27
27
    builtins,
 
28
    config,
28
29
    errors,
29
30
    osutils,
30
31
    revision as _mod_revision,
66
67
            try:
67
68
                # Run func if set
68
69
                self.tcp_server = tcp_server
69
 
                if not func is None:
 
70
                if func is not None:
70
71
                    try:
71
72
                        func(*func_args, **func_kwargs)
72
73
                    except Exception, e:
87
88
        SmartTCPServer.hooks.install_named_hook(
88
89
            'server_started_ex', on_server_start,
89
90
            'run_bzr_serve_then_func hook')
 
91
        # It seesm thread.interrupt_main() will not raise KeyboardInterrupt
 
92
        # until after socket.accept returns. So we set the timeout low to make
 
93
        # the test faster.
 
94
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
90
95
        # start a TCP server
91
96
        try:
92
97
            out, err = self.run_bzr(['serve'] + list(serve_args),
266
271
        f.close()
267
272
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
268
273
 
 
274
    def test_bzr_serve_supports_configurable_timeout(self):
 
275
        gs = config.GlobalStack()
 
276
        gs.set('serve.client_timeout', 0.2)
 
277
        process, url = self.start_server_port()
 
278
        self.build_tree_contents([('a_file', 'contents\n')])
 
279
        # We can connect and issue a request
 
280
        t = transport.get_transport_from_url(url)
 
281
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
282
        # However, if we just wait for more content from the server, it will
 
283
        # eventually disconnect us.
 
284
        # TODO: Use something like signal.alarm() so that if the server doesn't
 
285
        #       properly handle the timeout, we end up failing the test instead
 
286
        #       of hanging forever.
 
287
        m = t.get_smart_medium()
 
288
        m.read_bytes(1)
 
289
        # Now, we wait for timeout to trigger
 
290
        err = process.stderr.readline()
 
291
        self.assertEqual(
 
292
            'Connection Timeout: disconnecting client after 0.2 seconds\n',
 
293
            err)
 
294
        self.assertServerFinishesCleanly(process)
 
295
 
 
296
    def test_bzr_serve_supports_client_timeout(self):
 
297
        process, url = self.start_server_port(['--client-timeout=0.1'])
 
298
        self.build_tree_contents([('a_file', 'contents\n')])
 
299
        # We can connect and issue a request
 
300
        t = transport.get_transport_from_url(url)
 
301
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
302
        # However, if we just wait for more content from the server, it will
 
303
        # eventually disconnect us.
 
304
        # TODO: Use something like signal.alarm() so that if the server doesn't
 
305
        #       properly handle the timeout, we end up failing the test instead
 
306
        #       of hanging forever.
 
307
        m = t.get_smart_medium()
 
308
        m.read_bytes(1)
 
309
        # Now, we wait for timeout to trigger
 
310
        err = process.stderr.readline()
 
311
        self.assertEqual(
 
312
            'Connection Timeout: disconnecting client after 0.1 seconds\n',
 
313
            err)
 
314
        self.assertServerFinishesCleanly(process)
 
315
 
 
316
    def test_bzr_serve_graceful_shutdown(self):
 
317
        big_contents = 'a'*64*1024
 
318
        self.build_tree_contents([('bigfile', big_contents)])
 
319
        process, url = self.start_server_port(['--client-timeout=1.0'])
 
320
        t = transport.get_transport_from_url(url)
 
321
        m = t.get_smart_medium()
 
322
        c = client._SmartClient(m)
 
323
        # Start, but don't finish a response
 
324
        resp, response_handler = c.call_expecting_body('get', 'bigfile')
 
325
        self.assertEqual(('ok',), resp)
 
326
        # Note: process.send_signal is a Python 2.6ism
 
327
        process.send_signal(signal.SIGHUP)
 
328
        # Wait for the server to notice the signal, and then read the actual
 
329
        # body of the response. That way we know that it is waiting for the
 
330
        # request to finish
 
331
        self.assertEqual('Requested to stop gracefully\n',
 
332
                         process.stderr.readline())
 
333
        self.assertEqual('Waiting for 1 client(s) to finish\n',
 
334
                         process.stderr.readline())
 
335
        body = response_handler.read_body_bytes()
 
336
        if body != big_contents:
 
337
            self.fail('Failed to properly read the contents of "bigfile"')
 
338
        # Now that our request is finished, the medium should notice it has
 
339
        # been disconnected.
 
340
        self.assertEqual('', m.read_bytes(1))
 
341
        # And the server should be stopping
 
342
        self.assertEqual(0, process.wait())
 
343
 
269
344
 
270
345
class TestCmdServeChrooting(TestBzrServeBase):
271
346
 
327
402
            self.fake_expanduser, lambda t: base_path)
328
403
        mem_transport = self.get_transport()
329
404
        mem_transport.mkdir_multi(['home', 'home/user'])
330
 
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
405
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
331
406
        self.addCleanup(bzr_server.tear_down)
332
407
        return bzr_server
333
408
 
349
424
        base_url = urlutils.local_path_to_url(base_dir) + '/'
350
425
        # Define a fake 'protocol' to capture the transport that cmd_serve
351
426
        # passes to serve_bzr.
352
 
        def capture_transport(transport, host, port, inet):
 
427
        def capture_transport(transport, host, port, inet, timeout):
353
428
            self.bzr_serve_transport = transport
354
429
        cmd = builtins.cmd_serve()
355
430
        # Read-only
366
441
        self.assertEqual(base_url, self.bzr_serve_transport.base)
367
442
        self.assertEqual(base_dir,
368
443
            server_maker.get_base_path(self.bzr_serve_transport))
 
444
        # Read-only, from a URL
 
445
        cmd.run(directory=base_url, protocol=capture_transport)
 
446
        server_maker = BzrServerFactory()
 
447
        self.assertEqual(
 
448
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
449
        self.assertEqual(
 
450
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))