← 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: Naoki INADA
  • Date: 2009-10-29 10:01:19 UTC
  • mto: (4634.97.3 2.0)
  • mto: This revision was merged to the branch mainline in revision 4798.
  • Revision ID: inada-n@klab.jp-20091029100119-uckv9t7ej2qrghw3
import doc-ja rev90

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
64
77
        connection early to avoid polluting the test results.
65
78
        """
66
79
        try:
67
 
            SimpleHTTPRequestHandler.handle_one_request(self)
 
80
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
68
81
        except socket.error, e:
69
 
            if (len(e.args) > 0
70
 
                and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
71
 
                                  errno.ECONNABORTED,)):
72
 
                self.close_connection = 1
73
 
                pass
74
 
            else:
 
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.
 
85
            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)):
75
89
                raise
76
90
 
77
91
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
110
124
                    return 0, []
111
125
        return tail, ranges
112
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
 
113
147
    def send_range_content(self, file, start, length):
114
148
        file.seek(start)
115
149
        self.wfile.write(file.read(length))
130
164
    def get_multiple_ranges(self, file, file_size, ranges):
131
165
        self.send_response(206)
132
166
        self.send_header('Accept-Ranges', 'bytes')
133
 
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
134
 
        self.send_header("Content-Type",
135
 
                         "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)
136
183
        self.end_headers()
 
184
 
 
185
        # Send the multipart body
137
186
        for (start, end) in ranges:
138
 
            self.wfile.write("--%s\r\n" % boundary)
139
 
            self.send_header("Content-type", 'application/octet-stream')
140
 
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
141
 
                                                                  end,
142
 
                                                                  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))
143
191
            self.end_headers()
144
192
            self.send_range_content(file, start, end - start + 1)
145
 
            self.wfile.write("--%s\r\n" % boundary)
 
193
        # Final boundary
 
194
        self.wfile.write(boundary_line)
146
195
 
147
196
    def do_GET(self):
148
197
        """Serve a GET request.
149
198
 
150
199
        Handles the Range header.
151
200
        """
 
201
        # Update statistics
 
202
        self.server.test_case_server.GET_request_nb += 1
152
203
 
153
204
        path = self.translate_path(self.path)
154
205
        ranges_header_value = self.headers.get('Range')
155
206
        if ranges_header_value is None or os.path.isdir(path):
156
207
            # Let the mother class handle most cases
157
 
            return SimpleHTTPRequestHandler.do_GET(self)
 
208
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
158
209
 
159
210
        try:
160
211
            # Always read in binary mode. Opening files in text
231
282
        return self._translate_path(path)
232
283
 
233
284
    def _translate_path(self, path):
234
 
        return SimpleHTTPRequestHandler.translate_path(self, path)
235
 
 
236
 
    if sys.platform == 'win32':
237
 
        # On win32 you cannot access non-ascii filenames without
238
 
        # decoding them into unicode first.
239
 
        # However, under Linux, you can access bytestream paths
240
 
        # without any problems. If this function was always active
241
 
        # it would probably break tests when LANG=C was set
242
 
        def _translate_path(self, path):
243
 
            """Translate a /-separated PATH to the local filename syntax.
244
 
 
245
 
            For bzr, all url paths are considered to be utf8 paths.
246
 
            On Linux, you can access these paths directly over the bytestream
247
 
            request, but on win32, you must decode them, and access them
248
 
            as Unicode files.
249
 
            """
250
 
            # abandon query parameters
251
 
            path = urlparse.urlparse(path)[2]
252
 
            path = posixpath.normpath(urllib.unquote(path))
253
 
            path = path.decode('utf-8')
254
 
            words = path.split('/')
255
 
            words = filter(None, words)
256
 
            path = os.getcwdu()
257
 
            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:
258
304
                drive, word = os.path.splitdrive(word)
259
 
                head, word = os.path.split(word)
260
 
                if word in (os.curdir, os.pardir): continue
261
 
                path = os.path.join(path, word)
262
 
            return path
263
 
 
264
 
 
265
 
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
266
 
 
267
 
    def __init__(self, server_address, RequestHandlerClass,
268
 
                 test_case_server):
269
 
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
270
 
                                           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):
271
314
        # test_case_server can be used to communicate between the
272
315
        # tests and the server (or the request handler and the
273
316
        # server), allowing dynamic behaviors to be defined from
274
317
        # the tests cases.
275
318
        self.test_case_server = test_case_server
276
 
 
277
 
    def server_close(self):
278
 
        """Called to clean-up the server.
279
 
 
280
 
        Since the server may be in a blocking read, we shutdown the socket
281
 
        before closing it.
282
 
        """
283
 
        self.socket.shutdown(socket.SHUT_RDWR)
284
 
        BaseHTTPServer.HTTPServer.server_close(self)
285
 
 
286
 
 
287
 
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):
288
404
    """A test server for http transports.
289
405
 
290
406
    Subclasses can provide a specific request handler.
291
407
    """
292
408
 
 
409
    # The real servers depending on the protocol
 
410
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
 
411
                         'HTTP/1.1': TestingThreadingHTTPServer,
 
412
                         }
 
413
 
293
414
    # Whether or not we proxy the requests (see
294
415
    # TestingHTTPRequestHandler.translate_path).
295
416
    proxy_requests = False
297
418
    # used to form the url that connects to this server
298
419
    _url_protocol = 'http'
299
420
 
300
 
    # Subclasses can provide a specific request handler
301
 
    def __init__(self, request_handler=TestingHTTPRequestHandler):
302
 
        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)
303
432
        self.request_handler = request_handler
304
433
        self.host = 'localhost'
305
434
        self.port = 0
306
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)
307
446
 
308
447
    def _get_httpd(self):
309
448
        if self._httpd is None:
310
 
            self._httpd = TestingHTTPServer((self.host, self.port),
311
 
                                            self.request_handler,
312
 
                                            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)
313
465
            host, self.port = self._httpd.socket.getsockname()
314
466
        return self._httpd
315
467
 
316
468
    def _http_start(self):
317
 
        httpd = self._get_httpd()
318
 
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
319
 
                                               self.host,
320
 
                                               self.port)
321
 
        self._http_starting.release()
 
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()
322
486
 
 
487
        # From now on, exceptions are taken care of by the
 
488
        # SocketServer.BaseServer or the request handler.
323
489
        while self._http_running:
324
490
            try:
 
491
                # Really an HTTP connection but the python framework is generic
 
492
                # and call them requests
325
493
                httpd.handle_request()
326
494
            except socket.timeout:
327
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
328
504
 
329
505
    def _get_remote_url(self, path):
330
506
        path_parts = path.split(os.path.sep)
344
520
 
345
521
    def setUp(self, backing_transport_server=None):
346
522
        """See bzrlib.transport.Server.setUp.
347
 
        
 
523
 
348
524
        :param backing_transport_server: The transport that requests over this
349
525
            protocol should be forwarded to. Note that this is currently not
350
526
            supported for HTTP.
351
527
        """
352
528
        # XXX: TODO: make the server back onto vfs_server rather than local
353
529
        # disk.
354
 
        assert backing_transport_server is None or \
355
 
            isinstance(backing_transport_server, LocalURLServer), \
356
 
            "HTTPServer currently assumes local transport, got %s" % \
357
 
            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)
358
535
        self._home_dir = os.getcwdu()
359
536
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
537
        self._http_base_url = None
 
538
 
 
539
        # Create the server thread
360
540
        self._http_starting = threading.Lock()
361
541
        self._http_starting.acquire()
362
 
        self._http_running = True
363
 
        self._http_base_url = None
364
542
        self._http_thread = threading.Thread(target=self._http_start)
365
543
        self._http_thread.setDaemon(True)
 
544
        self._http_exception = None
366
545
        self._http_thread.start()
 
546
 
367
547
        # Wait for the server thread to start (i.e release the lock)
368
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
369
554
        self._http_starting.release()
370
555
        self.logs = []
371
556
 
372
557
    def tearDown(self):
373
558
        """See bzrlib.transport.Server.tearDown."""
374
 
        self._httpd.server_close()
 
559
        self._httpd.tearDown()
375
560
        self._http_running = False
376
 
        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.
377
564
 
378
565
    def get_url(self):
379
566
        """See bzrlib.transport.Server.get_url."""
383
570
        """See bzrlib.transport.Server.get_bogus_url."""
384
571
        # this is chosen to try to prevent trouble with proxies, weird dns,
385
572
        # etc
386
 
        return 'http://127.0.0.1:1/'
 
573
        return self._url_protocol + '://127.0.0.1:1/'
387
574
 
388
575
 
389
576
class HttpServer_urllib(HttpServer):