← 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: John Arbash Meinel
  • Date: 2009-08-25 18:45:40 UTC
  • mto: (4634.6.15 2.0)
  • mto: This revision was merged to the branch mainline in revision 4667.
  • Revision ID: john@arbash-meinel.com-20090825184540-6dn3xjq62xhgj2gq
Add support for skipping ghost nodes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
 
import BaseHTTPServer
18
17
import errno
 
18
import httplib
19
19
import os
20
 
from SimpleHTTPServer import SimpleHTTPRequestHandler
21
 
import socket
22
20
import posixpath
23
21
import random
24
22
import re
 
23
import select
 
24
import SimpleHTTPServer
 
25
import socket
 
26
import SocketServer
25
27
import sys
26
28
import threading
27
29
import time
28
30
import urllib
29
31
import urlparse
30
32
 
31
 
from bzrlib.transport import Server
32
 
from bzrlib.transport.local import LocalURLServer
33
 
 
34
 
 
35
 
class WebserverNotAvailable(Exception):
36
 
    pass
 
33
from bzrlib import transport
 
34
from bzrlib.transport import local
37
35
 
38
36
 
39
37
class BadWebserverPath(ValueError):
41
39
        return 'path %s is not in %s' % self.args
42
40
 
43
41
 
44
 
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
 
42
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
45
43
    """Handles one request.
46
44
 
47
 
    A TestingHTTPRequestHandler is instantiated for every request
48
 
    received by the associated server.
 
45
    A TestingHTTPRequestHandler is instantiated for every request received by
 
46
    the associated server. Note that 'request' here is inherited from the base
 
47
    TCPServer class, for the HTTP server it is really a connection which itself
 
48
    will handle one or several HTTP requests.
49
49
    """
 
50
    # Default protocol version
 
51
    protocol_version = 'HTTP/1.1'
 
52
 
 
53
    # The Message-like class used to parse the request headers
 
54
    MessageClass = httplib.HTTPMessage
 
55
 
 
56
    def setup(self):
 
57
        SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
 
58
        self._cwd = self.server._home_dir
 
59
        tcs = self.server.test_case_server
 
60
        if tcs.protocol_version is not None:
 
61
            # If the test server forced a protocol version, use it
 
62
            self.protocol_version = tcs.protocol_version
50
63
 
51
64
    def log_message(self, format, *args):
52
65
        tcs = self.server.test_case_server
60
73
    def handle_one_request(self):
61
74
        """Handle a single HTTP request.
62
75
 
63
 
        You normally don't need to override this method; see the class
64
 
        __doc__ string for information on how to handle specific HTTP
65
 
        commands such as GET and POST.
66
 
 
 
76
        We catch all socket errors occurring when the client close the
 
77
        connection early to avoid polluting the test results.
67
78
        """
68
 
        for i in xrange(1,11): # Don't try more than 10 times
69
 
            try:
70
 
                self.raw_requestline = self.rfile.readline()
71
 
            except socket.error, e:
72
 
                if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
73
 
                    # omitted for now because some tests look at the log of
74
 
                    # the server and expect to see no errors.  see recent
75
 
                    # email thread. -- mbp 20051021. 
76
 
                    ## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
77
 
                    time.sleep(0.01)
78
 
                    continue
79
 
                raise
80
 
            else:
81
 
                break
82
 
        if not self.raw_requestline:
 
79
        try:
 
80
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
81
        except socket.error, e:
 
82
            # Any socket error should close the connection, but some errors are
 
83
            # due to the client closing early and we don't want to pollute test
 
84
            # results, so we raise only the others.
83
85
            self.close_connection = 1
84
 
            return
85
 
        if not self.parse_request(): # An error code has been sent, just exit
86
 
            return
87
 
        mname = 'do_' + self.command
88
 
        if getattr(self, mname, None) is None:
89
 
            self.send_error(501, "Unsupported method (%r)" % self.command)
90
 
            return
91
 
        method = getattr(self, mname)
92
 
        method()
 
86
            if (len(e.args) == 0
 
87
                or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
 
88
                                     errno.ECONNABORTED, errno.EBADF)):
 
89
                raise
93
90
 
94
91
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
95
92
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
127
124
                    return 0, []
128
125
        return tail, ranges
129
126
 
 
127
    def _header_line_length(self, keyword, value):
 
128
        header_line = '%s: %s\r\n' % (keyword, value)
 
129
        return len(header_line)
 
130
 
 
131
    def send_head(self):
 
132
        """Overrides base implementation to work around a bug in python2.5."""
 
133
        path = self.translate_path(self.path)
 
134
        if os.path.isdir(path) and not self.path.endswith('/'):
 
135
            # redirect browser - doing basically what apache does when
 
136
            # DirectorySlash option is On which is quite common (braindead, but
 
137
            # common)
 
138
            self.send_response(301)
 
139
            self.send_header("Location", self.path + "/")
 
140
            # Indicates that the body is empty for HTTP/1.1 clients
 
141
            self.send_header('Content-Length', '0')
 
142
            self.end_headers()
 
143
            return None
 
144
 
 
145
        return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
 
146
 
130
147
    def send_range_content(self, file, start, length):
131
148
        file.seek(start)
132
149
        self.wfile.write(file.read(length))
147
164
    def get_multiple_ranges(self, file, file_size, ranges):
148
165
        self.send_response(206)
149
166
        self.send_header('Accept-Ranges', 'bytes')
150
 
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
151
 
        self.send_header("Content-Type",
152
 
                         "multipart/byteranges; boundary=%s" % boundary)
 
167
        boundary = '%d' % random.randint(0,0x7FFFFFFF)
 
168
        self.send_header('Content-Type',
 
169
                         'multipart/byteranges; boundary=%s' % boundary)
 
170
        boundary_line = '--%s\r\n' % boundary
 
171
        # Calculate the Content-Length
 
172
        content_length = 0
 
173
        for (start, end) in ranges:
 
174
            content_length += len(boundary_line)
 
175
            content_length += self._header_line_length(
 
176
                'Content-type', 'application/octet-stream')
 
177
            content_length += self._header_line_length(
 
178
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
 
179
            content_length += len('\r\n') # end headers
 
180
            content_length += end - start + 1
 
181
        content_length += len(boundary_line)
 
182
        self.send_header('Content-length', content_length)
153
183
        self.end_headers()
 
184
 
 
185
        # Send the multipart body
154
186
        for (start, end) in ranges:
155
 
            self.wfile.write("--%s\r\n" % boundary)
156
 
            self.send_header("Content-type", 'application/octet-stream')
157
 
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
158
 
                                                                  end,
159
 
                                                                  file_size))
 
187
            self.wfile.write(boundary_line)
 
188
            self.send_header('Content-type', 'application/octet-stream')
 
189
            self.send_header('Content-Range', 'bytes %d-%d/%d'
 
190
                             % (start, end, file_size))
160
191
            self.end_headers()
161
192
            self.send_range_content(file, start, end - start + 1)
162
 
            self.wfile.write("--%s\r\n" % boundary)
 
193
        # Final boundary
 
194
        self.wfile.write(boundary_line)
163
195
 
164
196
    def do_GET(self):
165
197
        """Serve a GET request.
166
198
 
167
199
        Handles the Range header.
168
200
        """
 
201
        # Update statistics
 
202
        self.server.test_case_server.GET_request_nb += 1
169
203
 
170
204
        path = self.translate_path(self.path)
171
205
        ranges_header_value = self.headers.get('Range')
172
206
        if ranges_header_value is None or os.path.isdir(path):
173
207
            # Let the mother class handle most cases
174
 
            return SimpleHTTPRequestHandler.do_GET(self)
 
208
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
175
209
 
176
210
        try:
177
211
            # Always read in binary mode. Opening files in text
248
282
        return self._translate_path(path)
249
283
 
250
284
    def _translate_path(self, path):
251
 
        return SimpleHTTPRequestHandler.translate_path(self, path)
252
 
 
253
 
    if sys.platform == 'win32':
254
 
        # On win32 you cannot access non-ascii filenames without
255
 
        # decoding them into unicode first.
256
 
        # However, under Linux, you can access bytestream paths
257
 
        # without any problems. If this function was always active
258
 
        # it would probably break tests when LANG=C was set
259
 
        def _translate_path(self, path):
260
 
            """Translate a /-separated PATH to the local filename syntax.
261
 
 
262
 
            For bzr, all url paths are considered to be utf8 paths.
263
 
            On Linux, you can access these paths directly over the bytestream
264
 
            request, but on win32, you must decode them, and access them
265
 
            as Unicode files.
266
 
            """
267
 
            # abandon query parameters
268
 
            path = urlparse.urlparse(path)[2]
269
 
            path = posixpath.normpath(urllib.unquote(path))
270
 
            path = path.decode('utf-8')
271
 
            words = path.split('/')
272
 
            words = filter(None, words)
273
 
            path = os.getcwdu()
274
 
            for word in words:
 
285
        """Translate a /-separated PATH to the local filename syntax.
 
286
 
 
287
        Note that we're translating http URLs here, not file URLs.
 
288
        The URL root location is the server's startup directory.
 
289
        Components that mean special things to the local file system
 
290
        (e.g. drive or directory names) are ignored.  (XXX They should
 
291
        probably be diagnosed.)
 
292
 
 
293
        Override from python standard library to stop it calling os.getcwd()
 
294
        """
 
295
        # abandon query parameters
 
296
        path = urlparse.urlparse(path)[2]
 
297
        path = posixpath.normpath(urllib.unquote(path))
 
298
        path = path.decode('utf-8')
 
299
        words = path.split('/')
 
300
        words = filter(None, words)
 
301
        path = self._cwd
 
302
        for num, word in enumerate(words):
 
303
            if num == 0:
275
304
                drive, word = os.path.splitdrive(word)
276
 
                head, word = os.path.split(word)
277
 
                if word in (os.curdir, os.pardir): continue
278
 
                path = os.path.join(path, word)
279
 
            return path
280
 
 
281
 
 
282
 
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
283
 
 
284
 
    def __init__(self, server_address, RequestHandlerClass,
285
 
                 test_case_server):
286
 
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
287
 
                                           RequestHandlerClass)
 
305
            head, word = os.path.split(word)
 
306
            if word in (os.curdir, os.pardir): continue
 
307
            path = os.path.join(path, word)
 
308
        return path
 
309
 
 
310
 
 
311
class TestingHTTPServerMixin:
 
312
 
 
313
    def __init__(self, test_case_server):
288
314
        # test_case_server can be used to communicate between the
289
315
        # tests and the server (or the request handler and the
290
316
        # server), allowing dynamic behaviors to be defined from
291
317
        # the tests cases.
292
318
        self.test_case_server = test_case_server
293
 
 
294
 
 
295
 
class HttpServer(Server):
 
319
        self._home_dir = test_case_server._home_dir
 
320
 
 
321
    def tearDown(self):
 
322
         """Called to clean-up the server.
 
323
 
 
324
         Since the server may be (surely is, even) in a blocking listen, we
 
325
         shutdown its socket before closing it.
 
326
         """
 
327
         # Note that is this executed as part of the implicit tear down in the
 
328
         # main thread while the server runs in its own thread. The clean way
 
329
         # to tear down the server is to instruct him to stop accepting
 
330
         # connections and wait for the current connection(s) to end
 
331
         # naturally. To end the connection naturally, the http transports
 
332
         # should close their socket when they do not need to talk to the
 
333
         # server anymore. This happens naturally during the garbage collection
 
334
         # phase of the test transport objetcs (the server clients), so we
 
335
         # don't have to worry about them.  So, for the server, we must tear
 
336
         # down here, from the main thread, when the test have ended.  Note
 
337
         # that since the server is in a blocking operation and since python
 
338
         # use select internally, shutting down the socket is reliable and
 
339
         # relatively clean.
 
340
         try:
 
341
             self.socket.shutdown(socket.SHUT_RDWR)
 
342
         except socket.error, e:
 
343
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
 
344
             # windows (occurs before the first connection attempt
 
345
             # vila--20071230)
 
346
 
 
347
             # 'Socket is not connected' can also occur on OSX, with a
 
348
             # "regular" ENOTCONN (when something went wrong during test case
 
349
             # setup leading to self.setUp() *not* being called but
 
350
             # self.tearDown() still being called -- vila20081106
 
351
             if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
 
352
                 raise
 
353
         # Let the server properly close the socket
 
354
         self.server_close()
 
355
 
 
356
 
 
357
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
 
358
 
 
359
    def __init__(self, server_address, request_handler_class,
 
360
                 test_case_server):
 
361
        TestingHTTPServerMixin.__init__(self, test_case_server)
 
362
        SocketServer.TCPServer.__init__(self, server_address,
 
363
                                        request_handler_class)
 
364
 
 
365
 
 
366
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
 
367
                                 TestingHTTPServerMixin):
 
368
    """A threading HTTP test server for HTTP 1.1.
 
369
 
 
370
    Since tests can initiate several concurrent connections to the same http
 
371
    server, we need an independent connection for each of them. We achieve that
 
372
    by spawning a new thread for each connection.
 
373
    """
 
374
 
 
375
    def __init__(self, server_address, request_handler_class,
 
376
                 test_case_server):
 
377
        TestingHTTPServerMixin.__init__(self, test_case_server)
 
378
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
 
379
                                                 request_handler_class)
 
380
        # Decides how threads will act upon termination of the main
 
381
        # process. This is prophylactic as we should not leave the threads
 
382
        # lying around.
 
383
        self.daemon_threads = True
 
384
 
 
385
    def process_request_thread(self, request, client_address):
 
386
        SocketServer.ThreadingTCPServer.process_request_thread(
 
387
            self, request, client_address)
 
388
        # Under some circumstances (as in bug #383920), we need to force the
 
389
        # shutdown as python delays it until gc occur otherwise and the client
 
390
        # may hang.
 
391
        try:
 
392
            # The request process has been completed, the thread is about to
 
393
            # die, let's shutdown the socket if we can.
 
394
            request.shutdown(socket.SHUT_RDWR)
 
395
        except (socket.error, select.error), e:
 
396
            if e[0] in (errno.EBADF, errno.ENOTCONN):
 
397
                # Right, the socket is already down
 
398
                pass
 
399
            else:
 
400
                raise
 
401
 
 
402
 
 
403
class HttpServer(transport.Server):
296
404
    """A test server for http transports.
297
405
 
298
406
    Subclasses can provide a specific request handler.
299
407
    """
300
408
 
 
409
    # The real servers depending on the protocol
 
410
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
 
411
                         'HTTP/1.1': TestingThreadingHTTPServer,
 
412
                         }
 
413
 
301
414
    # Whether or not we proxy the requests (see
302
415
    # TestingHTTPRequestHandler.translate_path).
303
416
    proxy_requests = False
305
418
    # used to form the url that connects to this server
306
419
    _url_protocol = 'http'
307
420
 
308
 
    # Subclasses can provide a specific request handler
309
 
    def __init__(self, request_handler=TestingHTTPRequestHandler):
310
 
        Server.__init__(self)
 
421
    def __init__(self, request_handler=TestingHTTPRequestHandler,
 
422
                 protocol_version=None):
 
423
        """Constructor.
 
424
 
 
425
        :param request_handler: a class that will be instantiated to handle an
 
426
            http connection (one or several requests).
 
427
 
 
428
        :param protocol_version: if specified, will override the protocol
 
429
            version of the request handler.
 
430
        """
 
431
        transport.Server.__init__(self)
311
432
        self.request_handler = request_handler
312
433
        self.host = 'localhost'
313
434
        self.port = 0
314
435
        self._httpd = None
 
436
        self.protocol_version = protocol_version
 
437
        # Allows tests to verify number of GET requests issued
 
438
        self.GET_request_nb = 0
 
439
 
 
440
    def create_httpd(self, serv_cls, rhandler_cls):
 
441
        return serv_cls((self.host, self.port), self.request_handler, self)
 
442
 
 
443
    def __repr__(self):
 
444
        return "%s(%s:%s)" % \
 
445
            (self.__class__.__name__, self.host, self.port)
315
446
 
316
447
    def _get_httpd(self):
317
448
        if self._httpd is None:
318
 
            self._httpd = TestingHTTPServer((self.host, self.port),
319
 
                                            self.request_handler,
320
 
                                            self)
 
449
            rhandler = self.request_handler
 
450
            # Depending on the protocol version, we will create the approriate
 
451
            # server
 
452
            if self.protocol_version is None:
 
453
                # Use the request handler one
 
454
                proto_vers = rhandler.protocol_version
 
455
            else:
 
456
                # Use our own, it will be used to override the request handler
 
457
                # one too.
 
458
                proto_vers = self.protocol_version
 
459
            # Create the appropriate server for the required protocol
 
460
            serv_cls = self.http_server_class.get(proto_vers, None)
 
461
            if serv_cls is None:
 
462
                raise httplib.UnknownProtocol(proto_vers)
 
463
            else:
 
464
                self._httpd = self.create_httpd(serv_cls, rhandler)
321
465
            host, self.port = self._httpd.socket.getsockname()
322
466
        return self._httpd
323
467
 
324
468
    def _http_start(self):
325
 
        httpd = self._get_httpd()
326
 
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
327
 
                                               self.host,
328
 
                                               self.port)
329
 
        self._http_starting.release()
330
 
        httpd.socket.settimeout(0.1)
 
469
        """Server thread main entry point. """
 
470
        self._http_running = False
 
471
        try:
 
472
            try:
 
473
                httpd = self._get_httpd()
 
474
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
475
                                                       self.host, self.port)
 
476
                self._http_running = True
 
477
            except:
 
478
                # Whatever goes wrong, we save the exception for the main
 
479
                # thread. Note that since we are running in a thread, no signal
 
480
                # can be received, so we don't care about KeyboardInterrupt.
 
481
                self._http_exception = sys.exc_info()
 
482
        finally:
 
483
            # Release the lock or the main thread will block and the whole
 
484
            # process will hang.
 
485
            self._http_starting.release()
331
486
 
 
487
        # From now on, exceptions are taken care of by the
 
488
        # SocketServer.BaseServer or the request handler.
332
489
        while self._http_running:
333
490
            try:
 
491
                # Really an HTTP connection but the python framework is generic
 
492
                # and call them requests
334
493
                httpd.handle_request()
335
494
            except socket.timeout:
336
495
                pass
 
496
            except (socket.error, select.error), e:
 
497
               if e[0] == errno.EBADF:
 
498
                   # Starting with python-2.6, handle_request may raise socket
 
499
                   # or select exceptions when the server is shut down (as we
 
500
                   # do).
 
501
                   pass
 
502
               else:
 
503
                   raise
337
504
 
338
505
    def _get_remote_url(self, path):
339
506
        path_parts = path.split(os.path.sep)
353
520
 
354
521
    def setUp(self, backing_transport_server=None):
355
522
        """See bzrlib.transport.Server.setUp.
356
 
        
 
523
 
357
524
        :param backing_transport_server: The transport that requests over this
358
525
            protocol should be forwarded to. Note that this is currently not
359
526
            supported for HTTP.
360
527
        """
361
528
        # XXX: TODO: make the server back onto vfs_server rather than local
362
529
        # disk.
363
 
        assert backing_transport_server is None or \
364
 
            isinstance(backing_transport_server, LocalURLServer), \
365
 
            "HTTPServer currently assumes local transport, got %s" % \
366
 
            backing_transport_server
 
530
        if not (backing_transport_server is None or \
 
531
                isinstance(backing_transport_server, local.LocalURLServer)):
 
532
            raise AssertionError(
 
533
                "HTTPServer currently assumes local transport, got %s" % \
 
534
                backing_transport_server)
367
535
        self._home_dir = os.getcwdu()
368
536
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
537
        self._http_base_url = None
 
538
 
 
539
        # Create the server thread
369
540
        self._http_starting = threading.Lock()
370
541
        self._http_starting.acquire()
371
 
        self._http_running = True
372
 
        self._http_base_url = None
373
542
        self._http_thread = threading.Thread(target=self._http_start)
374
543
        self._http_thread.setDaemon(True)
 
544
        self._http_exception = None
375
545
        self._http_thread.start()
 
546
 
376
547
        # Wait for the server thread to start (i.e release the lock)
377
548
        self._http_starting.acquire()
 
549
 
 
550
        if self._http_exception is not None:
 
551
            # Something went wrong during server start
 
552
            exc_class, exc_value, exc_tb = self._http_exception
 
553
            raise exc_class, exc_value, exc_tb
378
554
        self._http_starting.release()
379
555
        self.logs = []
380
556
 
381
557
    def tearDown(self):
382
558
        """See bzrlib.transport.Server.tearDown."""
 
559
        self._httpd.tearDown()
383
560
        self._http_running = False
384
 
        self._http_thread.join()
 
561
        # We don't need to 'self._http_thread.join()' here since the thread is
 
562
        # a daemonic one and will be garbage collected anyway. Joining just
 
563
        # slows us down for no added benefit.
385
564
 
386
565
    def get_url(self):
387
566
        """See bzrlib.transport.Server.get_url."""
391
570
        """See bzrlib.transport.Server.get_bogus_url."""
392
571
        # this is chosen to try to prevent trouble with proxies, weird dns,
393
572
        # etc
394
 
        return 'http://127.0.0.1:1/'
 
573
        return self._url_protocol + '://127.0.0.1:1/'
395
574
 
396
575
 
397
576
class HttpServer_urllib(HttpServer):