← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_server.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import errno
18
18
import httplib
20
20
import posixpath
21
21
import random
22
22
import re
23
 
import select
24
23
import SimpleHTTPServer
25
24
import socket
26
 
import SocketServer
27
 
import sys
28
 
import threading
29
 
import time
30
25
import urllib
31
26
import urlparse
32
27
 
33
 
from bzrlib import transport
34
 
from bzrlib.transport import local
35
 
 
36
 
 
37
 
class WebserverNotAvailable(Exception):
38
 
    pass
 
28
from bzrlib.tests import test_server
39
29
 
40
30
 
41
31
class BadWebserverPath(ValueError):
74
64
                self.headers.get('referer', '-'),
75
65
                self.headers.get('user-agent', '-'))
76
66
 
 
67
    def handle(self):
 
68
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
 
69
        # Some client (pycurl, I'm looking at you) are more picky than others
 
70
        # and require that the socket itself is closed
 
71
        # (SocketServer.StreamRequestHandler only close the two associated
 
72
        # 'makefile' objects)
 
73
        self.connection.close()
 
74
 
77
75
    def handle_one_request(self):
78
76
        """Handle a single HTTP request.
79
77
 
81
79
        connection early to avoid polluting the test results.
82
80
        """
83
81
        try:
84
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
82
            self._handle_one_request()
85
83
        except socket.error, e:
86
84
            # Any socket error should close the connection, but some errors are
87
85
            # due to the client closing early and we don't want to pollute test
92
90
                                     errno.ECONNABORTED, errno.EBADF)):
93
91
                raise
94
92
 
95
 
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
 
93
    error_content_type = 'text/plain'
 
94
    error_message_format = '''\
 
95
Error code: %(code)s.
 
96
Message: %(message)s.
 
97
'''
 
98
 
 
99
    def send_error(self, code, message=None):
 
100
        """Send and log an error reply.
 
101
 
 
102
        We redefine the python-provided version to be able to set a 
 
103
        ``Content-Length`` header as some http/1.1 clients complain otherwise
 
104
        (see bug #568421).
 
105
 
 
106
        :param code: The HTTP error code.
 
107
 
 
108
        :param message: The explanation of the error code, Defaults to a short
 
109
             entry.
 
110
        """
 
111
 
 
112
        if message is None:
 
113
            try:
 
114
                message = self.responses[code][0]
 
115
            except KeyError:
 
116
                message = '???'
 
117
        self.log_error("code %d, message %s", code, message)
 
118
        content = (self.error_message_format %
 
119
                   {'code': code, 'message': message})
 
120
        self.send_response(code, message)
 
121
        self.send_header("Content-Type", self.error_content_type)
 
122
        self.send_header("Content-Length", "%d" % len(content))
 
123
        self.send_header('Connection', 'close')
 
124
        self.end_headers()
 
125
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
 
126
            self.wfile.write(content)
 
127
 
 
128
    def _handle_one_request(self):
 
129
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
130
 
 
131
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)?$')
96
132
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
97
133
 
98
 
    def parse_ranges(self, ranges_header):
99
 
        """Parse the range header value and returns ranges and tail.
100
 
 
101
 
        RFC2616 14.35 says that syntactically invalid range
102
 
        specifiers MUST be ignored. In that case, we return 0 for
103
 
        tail and [] for ranges.
 
134
    def _parse_ranges(self, ranges_header, file_size):
 
135
        """Parse the range header value and returns ranges.
 
136
 
 
137
        RFC2616 14.35 says that syntactically invalid range specifiers MUST be
 
138
        ignored. In that case, we return None instead of a range list.
 
139
 
 
140
        :param ranges_header: The 'Range' header value.
 
141
 
 
142
        :param file_size: The size of the requested file.
 
143
 
 
144
        :return: A list of (start, end) tuples or None if some invalid range
 
145
            specifier is encountered.
104
146
        """
105
 
        tail = 0
106
 
        ranges = []
107
147
        if not ranges_header.startswith('bytes='):
108
148
            # Syntactically invalid header
109
 
            return 0, []
 
149
            return None
110
150
 
 
151
        tail = None
 
152
        ranges = []
111
153
        ranges_header = ranges_header[len('bytes='):]
112
154
        for range_str in ranges_header.split(','):
113
 
            # FIXME: RFC2616 says end is optional and default to file_size
114
155
            range_match = self._range_regexp.match(range_str)
115
156
            if range_match is not None:
116
157
                start = int(range_match.group('start'))
117
 
                end = int(range_match.group('end'))
 
158
                end_match = range_match.group('end')
 
159
                if end_match is None:
 
160
                    # RFC2616 says end is optional and default to file_size
 
161
                    end = file_size
 
162
                else:
 
163
                    end = int(end_match)
118
164
                if start > end:
119
165
                    # Syntactically invalid range
120
 
                    return 0, []
 
166
                    return None
121
167
                ranges.append((start, end))
122
168
            else:
123
169
                tail_match = self._tail_regexp.match(range_str)
125
171
                    tail = int(tail_match.group('tail'))
126
172
                else:
127
173
                    # Syntactically invalid range
128
 
                    return 0, []
129
 
        return tail, ranges
 
174
                    return None
 
175
        if tail is not None:
 
176
            # Normalize tail into ranges
 
177
            ranges.append((max(0, file_size - tail), file_size))
 
178
 
 
179
        checked_ranges = []
 
180
        for start, end in ranges:
 
181
            if start >= file_size:
 
182
                # RFC2616 14.35, ranges are invalid if start >= file_size
 
183
                return None
 
184
            # RFC2616 14.35, end values should be truncated
 
185
            # to file_size -1 if they exceed it
 
186
            end = min(end, file_size - 1)
 
187
            checked_ranges.append((start, end))
 
188
        return checked_ranges
130
189
 
131
190
    def _header_line_length(self, keyword, value):
132
191
        header_line = '%s: %s\r\n' % (keyword, value)
141
200
            # common)
142
201
            self.send_response(301)
143
202
            self.send_header("Location", self.path + "/")
144
 
            # Indicates that the body is empty for HTTP/1.1 clients 
 
203
            # Indicates that the body is empty for HTTP/1.1 clients
145
204
            self.send_header('Content-Length', '0')
146
205
            self.end_headers()
147
206
            return None
181
240
            content_length += self._header_line_length(
182
241
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
183
242
            content_length += len('\r\n') # end headers
184
 
            content_length += end - start # + 1
 
243
            content_length += end - start + 1
185
244
        content_length += len(boundary_line)
186
245
        self.send_header('Content-length', content_length)
187
246
        self.end_headers()
216
275
            # mode may cause newline translations, making the
217
276
            # actual size of the content transmitted *less* than
218
277
            # the content-length!
219
 
            file = open(path, 'rb')
 
278
            f = open(path, 'rb')
220
279
        except IOError:
221
280
            self.send_error(404, "File not found")
222
281
            return
223
282
 
224
 
        file_size = os.fstat(file.fileno())[6]
225
 
        tail, ranges = self.parse_ranges(ranges_header_value)
226
 
        # Normalize tail into ranges
227
 
        if tail != 0:
228
 
            ranges.append((file_size - tail, file_size))
229
 
 
230
 
        self._satisfiable_ranges = True
231
 
        if len(ranges) == 0:
232
 
            self._satisfiable_ranges = False
233
 
        else:
234
 
            def check_range(range_specifier):
235
 
                start, end = range_specifier
236
 
                # RFC2616 14.35, ranges are invalid if start >= file_size
237
 
                if start >= file_size:
238
 
                    self._satisfiable_ranges = False # Side-effect !
239
 
                    return 0, 0
240
 
                # RFC2616 14.35, end values should be truncated
241
 
                # to file_size -1 if they exceed it
242
 
                end = min(end, file_size - 1)
243
 
                return start, end
244
 
 
245
 
            ranges = map(check_range, ranges)
246
 
 
247
 
        if not self._satisfiable_ranges:
 
283
        file_size = os.fstat(f.fileno())[6]
 
284
        ranges = self._parse_ranges(ranges_header_value, file_size)
 
285
        if not ranges:
248
286
            # RFC2616 14.16 and 14.35 says that when a server
249
287
            # encounters unsatisfiable range specifiers, it
250
288
            # SHOULD return a 416.
251
 
            file.close()
 
289
            f.close()
252
290
            # FIXME: We SHOULD send a Content-Range header too,
253
291
            # but the implementation of send_error does not
254
292
            # allows that. So far.
257
295
 
258
296
        if len(ranges) == 1:
259
297
            (start, end) = ranges[0]
260
 
            self.get_single_range(file, file_size, start, end)
 
298
            self.get_single_range(f, file_size, start, end)
261
299
        else:
262
 
            self.get_multiple_ranges(file, file_size, ranges)
263
 
        file.close()
 
300
            self.get_multiple_ranges(f, file_size, ranges)
 
301
        f.close()
264
302
 
265
303
    def translate_path(self, path):
266
304
        """Translate a /-separated PATH to the local filename syntax.
322
360
        self.test_case_server = test_case_server
323
361
        self._home_dir = test_case_server._home_dir
324
362
 
325
 
    def tearDown(self):
326
 
         """Called to clean-up the server.
327
 
 
328
 
         Since the server may be (surely is, even) in a blocking listen, we
329
 
         shutdown its socket before closing it.
330
 
         """
331
 
         # Note that is this executed as part of the implicit tear down in the
332
 
         # main thread while the server runs in its own thread. The clean way
333
 
         # to tear down the server is to instruct him to stop accepting
334
 
         # connections and wait for the current connection(s) to end
335
 
         # naturally. To end the connection naturally, the http transports
336
 
         # should close their socket when they do not need to talk to the
337
 
         # server anymore. This happens naturally during the garbage collection
338
 
         # phase of the test transport objetcs (the server clients), so we
339
 
         # don't have to worry about them.  So, for the server, we must tear
340
 
         # down here, from the main thread, when the test have ended.  Note
341
 
         # that since the server is in a blocking operation and since python
342
 
         # use select internally, shutting down the socket is reliable and
343
 
         # relatively clean.
344
 
         try:
345
 
             self.socket.shutdown(socket.SHUT_RDWR)
346
 
         except socket.error, e:
347
 
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
348
 
             # windows (occurs before the first connection attempt
349
 
             # vila--20071230)
350
 
             if not len(e.args) or e.args[0] != 10057:
351
 
                 raise
352
 
         # Let the server properly close the socket
353
 
         self.server_close()
354
 
 
355
 
 
356
 
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
 
363
 
 
364
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
357
365
 
358
366
    def __init__(self, server_address, request_handler_class,
359
367
                 test_case_server):
 
368
        test_server.TestingTCPServer.__init__(self, server_address,
 
369
                                              request_handler_class)
360
370
        TestingHTTPServerMixin.__init__(self, test_case_server)
361
 
        SocketServer.TCPServer.__init__(self, server_address,
362
 
                                        request_handler_class)
363
 
 
364
 
 
365
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
 
371
 
 
372
 
 
373
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
366
374
                                 TestingHTTPServerMixin):
367
375
    """A threading HTTP test server for HTTP 1.1.
368
376
 
370
378
    server, we need an independent connection for each of them. We achieve that
371
379
    by spawning a new thread for each connection.
372
380
    """
373
 
 
374
381
    def __init__(self, server_address, request_handler_class,
375
382
                 test_case_server):
 
383
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
 
384
                                                       request_handler_class)
376
385
        TestingHTTPServerMixin.__init__(self, test_case_server)
377
 
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
378
 
                                                 request_handler_class)
379
 
        # Decides how threads will act upon termination of the main
380
 
        # process. This is prophylactic as we should not leave the threads
381
 
        # lying around.
382
 
        self.daemon_threads = True
383
 
 
384
 
 
385
 
class HttpServer(transport.Server):
 
386
 
 
387
 
 
388
class HttpServer(test_server.TestingTCPServerInAThread):
386
389
    """A test server for http transports.
387
390
 
388
391
    Subclasses can provide a specific request handler.
410
413
        :param protocol_version: if specified, will override the protocol
411
414
            version of the request handler.
412
415
        """
413
 
        transport.Server.__init__(self)
414
 
        self.request_handler = request_handler
 
416
        # Depending on the protocol version, we will create the approriate
 
417
        # server
 
418
        if protocol_version is None:
 
419
            # Use the request handler one
 
420
            proto_vers = request_handler.protocol_version
 
421
        else:
 
422
            # Use our own, it will be used to override the request handler
 
423
            # one too.
 
424
            proto_vers = protocol_version
 
425
        # Get the appropriate server class for the required protocol
 
426
        serv_cls = self.http_server_class.get(proto_vers, None)
 
427
        if serv_cls is None:
 
428
            raise httplib.UnknownProtocol(proto_vers)
415
429
        self.host = 'localhost'
416
430
        self.port = 0
417
 
        self._httpd = None
418
 
        self.protocol_version = protocol_version
 
431
        super(HttpServer, self).__init__((self.host, self.port),
 
432
                                         serv_cls,
 
433
                                         request_handler)
 
434
        self.protocol_version = proto_vers
419
435
        # Allows tests to verify number of GET requests issued
420
436
        self.GET_request_nb = 0
421
 
 
422
 
    def __repr__(self):
423
 
        return "%s(%s:%s)" % \
424
 
            (self.__class__.__name__, self.host, self.port)
425
 
 
426
 
    def _get_httpd(self):
427
 
        if self._httpd is None:
428
 
            rhandler = self.request_handler
429
 
            # Depending on the protocol version, we will create the approriate
430
 
            # server
431
 
            if self.protocol_version is None:
432
 
                # Use the request handler one
433
 
                proto_vers = rhandler.protocol_version
434
 
            else:
435
 
                # Use our own, it will be used to override the request handler
436
 
                # one too.
437
 
                proto_vers = self.protocol_version
438
 
            # Create the appropriate server for the required protocol
439
 
            serv_cls = self.http_server_class.get(proto_vers, None)
440
 
            if serv_cls is None:
441
 
                raise httplib.UnknownProtocol(proto_vers)
442
 
            else:
443
 
                self._httpd = serv_cls((self.host, self.port), rhandler, self)
444
 
            host, self.port = self._httpd.socket.getsockname()
445
 
        return self._httpd
446
 
 
447
 
    def _http_start(self):
448
 
        """Server thread main entry point. """
449
 
        self._http_running = False
450
 
        try:
451
 
            try:
452
 
                httpd = self._get_httpd()
453
 
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
454
 
                                                       self.host, self.port)
455
 
                self._http_running = True
456
 
            except:
457
 
                # Whatever goes wrong, we save the exception for the main
458
 
                # thread. Note that since we are running in a thread, no signal
459
 
                # can be received, so we don't care about KeyboardInterrupt.
460
 
                self._http_exception = sys.exc_info()
461
 
        finally:
462
 
            # Release the lock or the main thread will block and the whole
463
 
            # process will hang.
464
 
            self._http_starting.release()
465
 
 
466
 
        # From now on, exceptions are taken care of by the
467
 
        # SocketServer.BaseServer or the request handler.
468
 
        while self._http_running:
469
 
            try:
470
 
                # Really an HTTP connection but the python framework is generic
471
 
                # and call them requests
472
 
                httpd.handle_request()
473
 
            except socket.timeout:
474
 
                pass
475
 
            except (socket.error, select.error), e:
476
 
               if e[0] == errno.EBADF:
477
 
                   # Starting with python-2.6, handle_request may raise socket
478
 
                   # or select exceptions when the server is shut down (as we
479
 
                   # do).
480
 
                   pass
481
 
               else:
482
 
                   raise
 
437
        self._http_base_url = None
 
438
        self.logs = []
 
439
 
 
440
    def create_server(self):
 
441
        return self.server_class(
 
442
            (self.host, self.port), self.request_handler_class, self)
483
443
 
484
444
    def _get_remote_url(self, path):
485
445
        path_parts = path.split(os.path.sep)
497
457
        """Capture Server log output."""
498
458
        self.logs.append(format % args)
499
459
 
500
 
    def setUp(self, backing_transport_server=None):
501
 
        """See bzrlib.transport.Server.setUp.
502
 
        
 
460
    def start_server(self, backing_transport_server=None):
 
461
        """See bzrlib.transport.Server.start_server.
 
462
 
503
463
        :param backing_transport_server: The transport that requests over this
504
464
            protocol should be forwarded to. Note that this is currently not
505
465
            supported for HTTP.
506
466
        """
507
467
        # XXX: TODO: make the server back onto vfs_server rather than local
508
468
        # disk.
509
 
        if not (backing_transport_server is None or \
510
 
                isinstance(backing_transport_server, local.LocalURLServer)):
 
469
        if not (backing_transport_server is None
 
470
                or isinstance(backing_transport_server,
 
471
                              test_server.LocalURLServer)):
511
472
            raise AssertionError(
512
 
                "HTTPServer currently assumes local transport, got %s" % \
 
473
                "HTTPServer currently assumes local transport, got %s" %
513
474
                backing_transport_server)
514
475
        self._home_dir = os.getcwdu()
515
476
        self._local_path_parts = self._home_dir.split(os.path.sep)
516
 
        self._http_base_url = None
517
 
 
518
 
        # Create the server thread
519
 
        self._http_starting = threading.Lock()
520
 
        self._http_starting.acquire()
521
 
        self._http_thread = threading.Thread(target=self._http_start)
522
 
        self._http_thread.setDaemon(True)
523
 
        self._http_exception = None
524
 
        self._http_thread.start()
525
 
 
526
 
        # Wait for the server thread to start (i.e release the lock)
527
 
        self._http_starting.acquire()
528
 
 
529
 
        if self._http_exception is not None:
530
 
            # Something went wrong during server start
531
 
            exc_class, exc_value, exc_tb = self._http_exception
532
 
            raise exc_class, exc_value, exc_tb
533
 
        self._http_starting.release()
534
477
        self.logs = []
535
478
 
536
 
    def tearDown(self):
537
 
        """See bzrlib.transport.Server.tearDown."""
538
 
        self._httpd.tearDown()
539
 
        self._http_running = False
540
 
        # We don't need to 'self._http_thread.join()' here since the thread is
541
 
        # a daemonic one and will be garbage collected anyway. Joining just
542
 
        # slows us down for no added benefit.
 
479
        super(HttpServer, self).start_server()
 
480
        self._http_base_url = '%s://%s:%s/' % (
 
481
            self._url_protocol, self.host, self.port)
543
482
 
544
483
    def get_url(self):
545
484
        """See bzrlib.transport.Server.get_url."""