← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/HttpServer.py

  • Committer: Martin Pool
  • Date: 2007-04-04 06:17:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2397.
  • Revision ID: mbp@sourcefrog.net-20070404061731-tt2xrzllqhbodn83
Contents of TODO file moved into bug tracker

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/HttpServer.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import BaseHTTPServer
17
18
import errno
18
 
import httplib
19
19
import os
 
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
 
21
import socket
20
22
import posixpath
21
23
import random
22
24
import re
23
 
import select
24
 
import SimpleHTTPServer
25
 
import socket
26
 
import SocketServer
27
25
import sys
28
26
import threading
29
27
import time
30
28
import urllib
31
29
import urlparse
32
30
 
33
 
from bzrlib import transport
34
 
from bzrlib.transport import local
 
31
from bzrlib.transport import Server
 
32
from bzrlib.transport.local import LocalURLServer
 
33
 
 
34
 
 
35
class WebserverNotAvailable(Exception):
 
36
    pass
35
37
 
36
38
 
37
39
class BadWebserverPath(ValueError):
39
41
        return 'path %s is not in %s' % self.args
40
42
 
41
43
 
42
 
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
43
 
    """Handles one request.
44
 
 
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
 
    """
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
 
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
63
45
 
64
46
    def log_message(self, format, *args):
65
47
        tcs = self.server.test_case_server
73
55
    def handle_one_request(self):
74
56
        """Handle a single HTTP request.
75
57
 
76
 
        We catch all socket errors occurring when the client close the
77
 
        connection early to avoid polluting the test results.
 
58
        You normally don't need to override this method; see the class
 
59
        __doc__ string for information on how to handle specific HTTP
 
60
        commands such as GET and POST.
 
61
 
78
62
        """
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.
 
63
        for i in xrange(1,11): # Don't try more than 10 times
 
64
            try:
 
65
                self.raw_requestline = self.rfile.readline()
 
66
            except socket.error, e:
 
67
                if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
 
68
                    # omitted for now because some tests look at the log of
 
69
                    # the server and expect to see no errors.  see recent
 
70
                    # email thread. -- mbp 20051021. 
 
71
                    ## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
 
72
                    time.sleep(0.01)
 
73
                    continue
 
74
                raise
 
75
            else:
 
76
                break
 
77
        if not self.raw_requestline:
85
78
            self.close_connection = 1
86
 
            if (len(e.args) == 0
87
 
                or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
88
 
                                     errno.ECONNABORTED, errno.EBADF)):
89
 
                raise
 
79
            return
 
80
        if not self.parse_request(): # An error code has been sent, just exit
 
81
            return
 
82
        mname = 'do_' + self.command
 
83
        if getattr(self, mname, None) is None:
 
84
            self.send_error(501, "Unsupported method (%r)" % self.command)
 
85
            return
 
86
        method = getattr(self, mname)
 
87
        method()
90
88
 
91
89
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
92
90
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
124
122
                    return 0, []
125
123
        return tail, ranges
126
124
 
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
 
 
147
125
    def send_range_content(self, file, start, length):
148
126
        file.seek(start)
149
127
        self.wfile.write(file.read(length))
164
142
    def get_multiple_ranges(self, file, file_size, ranges):
165
143
        self.send_response(206)
166
144
        self.send_header('Accept-Ranges', 'bytes')
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)
 
145
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
146
        self.send_header("Content-Type",
 
147
                         "multipart/byteranges; boundary=%s" % boundary)
183
148
        self.end_headers()
184
 
 
185
 
        # Send the multipart body
186
149
        for (start, end) in ranges:
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))
 
150
            self.wfile.write("--%s\r\n" % boundary)
 
151
            self.send_header("Content-type", 'application/octet-stream')
 
152
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
153
                                                                  end,
 
154
                                                                  file_size))
191
155
            self.end_headers()
192
156
            self.send_range_content(file, start, end - start + 1)
193
 
        # Final boundary
194
 
        self.wfile.write(boundary_line)
 
157
            self.wfile.write("--%s\r\n" % boundary)
195
158
 
196
159
    def do_GET(self):
197
160
        """Serve a GET request.
198
161
 
199
162
        Handles the Range header.
200
163
        """
201
 
        # Update statistics
202
 
        self.server.test_case_server.GET_request_nb += 1
203
164
 
204
165
        path = self.translate_path(self.path)
205
166
        ranges_header_value = self.headers.get('Range')
206
167
        if ranges_header_value is None or os.path.isdir(path):
207
168
            # Let the mother class handle most cases
208
 
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
169
            return SimpleHTTPRequestHandler.do_GET(self)
209
170
 
210
171
        try:
211
172
            # Always read in binary mode. Opening files in text
258
219
            self.get_multiple_ranges(file, file_size, ranges)
259
220
        file.close()
260
221
 
261
 
    def translate_path(self, path):
262
 
        """Translate a /-separated PATH to the local filename syntax.
263
 
 
264
 
        If the server requires it, proxy the path before the usual translation
265
 
        """
266
 
        if self.server.test_case_server.proxy_requests:
267
 
            # We need to act as a proxy and accept absolute urls,
268
 
            # which SimpleHTTPRequestHandler (parent) is not
269
 
            # ready for. So we just drop the protocol://host:port
270
 
            # part in front of the request-url (because we know
271
 
            # we would not forward the request to *another*
272
 
            # proxy).
273
 
 
274
 
            # So we do what SimpleHTTPRequestHandler.translate_path
275
 
            # do beginning with python 2.4.3: abandon query
276
 
            # parameters, scheme, host port, etc (which ensure we
277
 
            # provide the right behaviour on all python versions).
 
222
    if sys.platform == 'win32':
 
223
        # On win32 you cannot access non-ascii filenames without
 
224
        # decoding them into unicode first.
 
225
        # However, under Linux, you can access bytestream paths
 
226
        # without any problems. If this function was always active
 
227
        # it would probably break tests when LANG=C was set
 
228
        def translate_path(self, path):
 
229
            """Translate a /-separated PATH to the local filename syntax.
 
230
 
 
231
            For bzr, all url paths are considered to be utf8 paths.
 
232
            On Linux, you can access these paths directly over the bytestream
 
233
            request, but on win32, you must decode them, and access them
 
234
            as Unicode files.
 
235
            """
 
236
            # abandon query parameters
278
237
            path = urlparse.urlparse(path)[2]
279
 
            # And now, we can apply *our* trick to proxy files
280
 
            path += '-proxied'
281
 
 
282
 
        return self._translate_path(path)
283
 
 
284
 
    def _translate_path(self, path):
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:
 
238
            path = posixpath.normpath(urllib.unquote(path))
 
239
            path = path.decode('utf-8')
 
240
            words = path.split('/')
 
241
            words = filter(None, words)
 
242
            path = os.getcwdu()
 
243
            for word in words:
304
244
                drive, word = os.path.splitdrive(word)
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):
 
245
                head, word = os.path.split(word)
 
246
                if word in (os.curdir, os.pardir): continue
 
247
                path = os.path.join(path, word)
 
248
            return path
 
249
 
 
250
 
 
251
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
 
252
 
 
253
    def __init__(self, server_address, RequestHandlerClass,
 
254
                 test_case_server):
 
255
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
 
256
                                           RequestHandlerClass)
314
257
        # test_case_server can be used to communicate between the
315
258
        # tests and the server (or the request handler and the
316
259
        # server), allowing dynamic behaviors to be defined from
317
260
        # the tests cases.
318
261
        self.test_case_server = test_case_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
 
 
386
 
class HttpServer(transport.Server):
 
262
 
 
263
 
 
264
class HttpServer(Server):
387
265
    """A test server for http transports.
388
266
 
389
267
    Subclasses can provide a specific request handler.
390
268
    """
391
269
 
392
 
    # The real servers depending on the protocol
393
 
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
394
 
                         'HTTP/1.1': TestingThreadingHTTPServer,
395
 
                         }
396
 
 
397
 
    # Whether or not we proxy the requests (see
398
 
    # TestingHTTPRequestHandler.translate_path).
399
 
    proxy_requests = False
400
 
 
401
270
    # used to form the url that connects to this server
402
271
    _url_protocol = 'http'
403
272
 
404
 
    def __init__(self, request_handler=TestingHTTPRequestHandler,
405
 
                 protocol_version=None):
406
 
        """Constructor.
407
 
 
408
 
        :param request_handler: a class that will be instantiated to handle an
409
 
            http connection (one or several requests).
410
 
 
411
 
        :param protocol_version: if specified, will override the protocol
412
 
            version of the request handler.
413
 
        """
414
 
        transport.Server.__init__(self)
 
273
    # Subclasses can provide a specific request handler
 
274
    def __init__(self, request_handler=TestingHTTPRequestHandler):
 
275
        Server.__init__(self)
415
276
        self.request_handler = request_handler
416
277
        self.host = 'localhost'
417
278
        self.port = 0
418
279
        self._httpd = None
419
 
        self.protocol_version = protocol_version
420
 
        # Allows tests to verify number of GET requests issued
421
 
        self.GET_request_nb = 0
422
 
 
423
 
    def create_httpd(self, serv_cls, rhandler_cls):
424
 
        return serv_cls((self.host, self.port), self.request_handler, self)
425
 
 
426
 
    def __repr__(self):
427
 
        return "%s(%s:%s)" % \
428
 
            (self.__class__.__name__, self.host, self.port)
429
280
 
430
281
    def _get_httpd(self):
431
282
        if self._httpd is None:
432
 
            rhandler = self.request_handler
433
 
            # Depending on the protocol version, we will create the approriate
434
 
            # server
435
 
            if self.protocol_version is None:
436
 
                # Use the request handler one
437
 
                proto_vers = rhandler.protocol_version
438
 
            else:
439
 
                # Use our own, it will be used to override the request handler
440
 
                # one too.
441
 
                proto_vers = self.protocol_version
442
 
            # Create the appropriate server for the required protocol
443
 
            serv_cls = self.http_server_class.get(proto_vers, None)
444
 
            if serv_cls is None:
445
 
                raise httplib.UnknownProtocol(proto_vers)
446
 
            else:
447
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
 
283
            self._httpd = TestingHTTPServer((self.host, self.port),
 
284
                                            self.request_handler,
 
285
                                            self)
448
286
            host, self.port = self._httpd.socket.getsockname()
449
287
        return self._httpd
450
288
 
451
289
    def _http_start(self):
452
 
        """Server thread main entry point. """
453
 
        self._http_running = False
454
 
        try:
455
 
            try:
456
 
                httpd = self._get_httpd()
457
 
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
458
 
                                                       self.host, self.port)
459
 
                self._http_running = True
460
 
            except:
461
 
                # Whatever goes wrong, we save the exception for the main
462
 
                # thread. Note that since we are running in a thread, no signal
463
 
                # can be received, so we don't care about KeyboardInterrupt.
464
 
                self._http_exception = sys.exc_info()
465
 
        finally:
466
 
            # Release the lock or the main thread will block and the whole
467
 
            # process will hang.
468
 
            self._http_starting.release()
 
290
        httpd = self._get_httpd()
 
291
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
292
                                               self.host,
 
293
                                               self.port)
 
294
        self._http_starting.release()
 
295
        httpd.socket.settimeout(0.1)
469
296
 
470
 
        # From now on, exceptions are taken care of by the
471
 
        # SocketServer.BaseServer or the request handler.
472
297
        while self._http_running:
473
298
            try:
474
 
                # Really an HTTP connection but the python framework is generic
475
 
                # and call them requests
476
299
                httpd.handle_request()
477
300
            except socket.timeout:
478
301
                pass
479
 
            except (socket.error, select.error), e:
480
 
               if e[0] == errno.EBADF:
481
 
                   # Starting with python-2.6, handle_request may raise socket
482
 
                   # or select exceptions when the server is shut down (as we
483
 
                   # do).
484
 
                   pass
485
 
               else:
486
 
                   raise
487
302
 
488
303
    def _get_remote_url(self, path):
489
304
        path_parts = path.split(os.path.sep)
503
318
 
504
319
    def setUp(self, backing_transport_server=None):
505
320
        """See bzrlib.transport.Server.setUp.
506
 
 
 
321
        
507
322
        :param backing_transport_server: The transport that requests over this
508
323
            protocol should be forwarded to. Note that this is currently not
509
324
            supported for HTTP.
510
325
        """
511
326
        # XXX: TODO: make the server back onto vfs_server rather than local
512
327
        # disk.
513
 
        if not (backing_transport_server is None or \
514
 
                isinstance(backing_transport_server, local.LocalURLServer)):
515
 
            raise AssertionError(
516
 
                "HTTPServer currently assumes local transport, got %s" % \
517
 
                backing_transport_server)
 
328
        assert backing_transport_server is None or \
 
329
            isinstance(backing_transport_server, LocalURLServer), \
 
330
            "HTTPServer currently assumes local transport, got %s" % \
 
331
            backing_transport_server
518
332
        self._home_dir = os.getcwdu()
519
333
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
334
        self._http_starting = threading.Lock()
 
335
        self._http_starting.acquire()
 
336
        self._http_running = True
520
337
        self._http_base_url = None
521
 
 
522
 
        # Create the server thread
523
 
        self._http_starting = threading.Lock()
524
 
        self._http_starting.acquire()
525
338
        self._http_thread = threading.Thread(target=self._http_start)
526
339
        self._http_thread.setDaemon(True)
527
 
        self._http_exception = None
528
340
        self._http_thread.start()
529
 
 
530
341
        # Wait for the server thread to start (i.e release the lock)
531
342
        self._http_starting.acquire()
532
 
 
533
 
        if self._http_exception is not None:
534
 
            # Something went wrong during server start
535
 
            exc_class, exc_value, exc_tb = self._http_exception
536
 
            raise exc_class, exc_value, exc_tb
537
343
        self._http_starting.release()
538
344
        self.logs = []
539
345
 
540
346
    def tearDown(self):
541
347
        """See bzrlib.transport.Server.tearDown."""
542
 
        self._httpd.tearDown()
543
348
        self._http_running = False
544
 
        # We don't need to 'self._http_thread.join()' here since the thread is
545
 
        # a daemonic one and will be garbage collected anyway. Joining just
546
 
        # slows us down for no added benefit.
 
349
        self._http_thread.join()
547
350
 
548
351
    def get_url(self):
549
352
        """See bzrlib.transport.Server.get_url."""
553
356
        """See bzrlib.transport.Server.get_bogus_url."""
554
357
        # this is chosen to try to prevent trouble with proxies, weird dns,
555
358
        # etc
556
 
        return self._url_protocol + '://127.0.0.1:1/'
 
359
        return 'http://127.0.0.1:1/'
557
360
 
558
361
 
559
362
class HttpServer_urllib(HttpServer):