/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/HttpServer.py

  • Committer: Martin Pool
  • Date: 2007-04-01 01:38:25 UTC
  • mto: (2389.1.1 0.15-to-trunk)
  • mto: This revision was merged to the branch mainline in revision 2390.
  • Revision ID: mbp@sourcefrog.net-20070401013825-zggofbeun985u2ri
(jam) trim st_ino to 32 bits in dirstate to avoid warning on win32

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/HttpServer.py
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
import BaseHTTPServer
 
18
import errno
 
19
import os
 
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
 
21
import socket
 
22
import posixpath
 
23
import random
 
24
import re
 
25
import sys
 
26
import threading
 
27
import time
 
28
import urllib
 
29
import urlparse
 
30
 
 
31
from bzrlib.transport import Server
 
32
 
 
33
 
 
34
class WebserverNotAvailable(Exception):
 
35
    pass
 
36
 
 
37
 
 
38
class BadWebserverPath(ValueError):
 
39
    def __str__(self):
 
40
        return 'path %s is not in %s' % self.args
 
41
 
 
42
 
 
43
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
 
44
 
 
45
    def log_message(self, format, *args):
 
46
        tcs = self.server.test_case_server
 
47
        tcs.log('webserver - %s - - [%s] %s "%s" "%s"',
 
48
                self.address_string(),
 
49
                self.log_date_time_string(),
 
50
                format % args,
 
51
                self.headers.get('referer', '-'),
 
52
                self.headers.get('user-agent', '-'))
 
53
 
 
54
    def handle_one_request(self):
 
55
        """Handle a single HTTP request.
 
56
 
 
57
        You normally don't need to override this method; see the class
 
58
        __doc__ string for information on how to handle specific HTTP
 
59
        commands such as GET and POST.
 
60
 
 
61
        """
 
62
        for i in xrange(1,11): # Don't try more than 10 times
 
63
            try:
 
64
                self.raw_requestline = self.rfile.readline()
 
65
            except socket.error, e:
 
66
                if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
 
67
                    # omitted for now because some tests look at the log of
 
68
                    # the server and expect to see no errors.  see recent
 
69
                    # email thread. -- mbp 20051021. 
 
70
                    ## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
 
71
                    time.sleep(0.01)
 
72
                    continue
 
73
                raise
 
74
            else:
 
75
                break
 
76
        if not self.raw_requestline:
 
77
            self.close_connection = 1
 
78
            return
 
79
        if not self.parse_request(): # An error code has been sent, just exit
 
80
            return
 
81
        mname = 'do_' + self.command
 
82
        if getattr(self, mname, None) is None:
 
83
            self.send_error(501, "Unsupported method (%r)" % self.command)
 
84
            return
 
85
        method = getattr(self, mname)
 
86
        method()
 
87
 
 
88
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
 
89
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
 
90
 
 
91
    def parse_ranges(self, ranges_header):
 
92
        """Parse the range header value and returns ranges and tail.
 
93
 
 
94
        RFC2616 14.35 says that syntactically invalid range
 
95
        specifiers MUST be ignored. In that case, we return 0 for
 
96
        tail and [] for ranges.
 
97
        """
 
98
        tail = 0
 
99
        ranges = []
 
100
        if not ranges_header.startswith('bytes='):
 
101
            # Syntactically invalid header
 
102
            return 0, []
 
103
 
 
104
        ranges_header = ranges_header[len('bytes='):]
 
105
        for range_str in ranges_header.split(','):
 
106
            # FIXME: RFC2616 says end is optional and default to file_size
 
107
            range_match = self._range_regexp.match(range_str)
 
108
            if range_match is not None:
 
109
                start = int(range_match.group('start'))
 
110
                end = int(range_match.group('end'))
 
111
                if start > end:
 
112
                    # Syntactically invalid range
 
113
                    return 0, []
 
114
                ranges.append((start, end))
 
115
            else:
 
116
                tail_match = self._tail_regexp.match(range_str)
 
117
                if tail_match is not None:
 
118
                    tail = int(tail_match.group('tail'))
 
119
                else:
 
120
                    # Syntactically invalid range
 
121
                    return 0, []
 
122
        return tail, ranges
 
123
 
 
124
    def send_range_content(self, file, start, length):
 
125
        file.seek(start)
 
126
        self.wfile.write(file.read(length))
 
127
 
 
128
    def get_single_range(self, file, file_size, start, end):
 
129
        self.send_response(206)
 
130
        length = end - start + 1
 
131
        self.send_header('Accept-Ranges', 'bytes')
 
132
        self.send_header("Content-Length", "%d" % length)
 
133
 
 
134
        self.send_header("Content-Type", 'application/octet-stream')
 
135
        self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
136
                                                              end,
 
137
                                                              file_size))
 
138
        self.end_headers()
 
139
        self.send_range_content(file, start, length)
 
140
 
 
141
    def get_multiple_ranges(self, file, file_size, ranges):
 
142
        self.send_response(206)
 
143
        self.send_header('Accept-Ranges', 'bytes')
 
144
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
145
        self.send_header("Content-Type",
 
146
                         "multipart/byteranges; boundary=%s" % boundary)
 
147
        self.end_headers()
 
148
        for (start, end) in ranges:
 
149
            self.wfile.write("--%s\r\n" % boundary)
 
150
            self.send_header("Content-type", 'application/octet-stream')
 
151
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
152
                                                                  end,
 
153
                                                                  file_size))
 
154
            self.end_headers()
 
155
            self.send_range_content(file, start, end - start + 1)
 
156
            self.wfile.write("--%s\r\n" % boundary)
 
157
 
 
158
    def do_GET(self):
 
159
        """Serve a GET request.
 
160
 
 
161
        Handles the Range header.
 
162
        """
 
163
 
 
164
        path = self.translate_path(self.path)
 
165
        ranges_header_value = self.headers.get('Range')
 
166
        if ranges_header_value is None or os.path.isdir(path):
 
167
            # Let the mother class handle most cases
 
168
            return SimpleHTTPRequestHandler.do_GET(self)
 
169
 
 
170
        try:
 
171
            # Always read in binary mode. Opening files in text
 
172
            # mode may cause newline translations, making the
 
173
            # actual size of the content transmitted *less* than
 
174
            # the content-length!
 
175
            file = open(path, 'rb')
 
176
        except IOError:
 
177
            self.send_error(404, "File not found")
 
178
            return
 
179
 
 
180
        file_size = os.fstat(file.fileno())[6]
 
181
        tail, ranges = self.parse_ranges(ranges_header_value)
 
182
        # Normalize tail into ranges
 
183
        if tail != 0:
 
184
            ranges.append((file_size - tail, file_size))
 
185
 
 
186
        self._satisfiable_ranges = True
 
187
        if len(ranges) == 0:
 
188
            self._satisfiable_ranges = False
 
189
        else:
 
190
            def check_range(range_specifier):
 
191
                start, end = range_specifier
 
192
                # RFC2616 14.35, ranges are invalid if start >= file_size
 
193
                if start >= file_size:
 
194
                    self._satisfiable_ranges = False # Side-effect !
 
195
                    return 0, 0
 
196
                # RFC2616 14.35, end values should be truncated
 
197
                # to file_size -1 if they exceed it
 
198
                end = min(end, file_size - 1)
 
199
                return start, end
 
200
 
 
201
            ranges = map(check_range, ranges)
 
202
 
 
203
        if not self._satisfiable_ranges:
 
204
            # RFC2616 14.16 and 14.35 says that when a server
 
205
            # encounters unsatisfiable range specifiers, it
 
206
            # SHOULD return a 416.
 
207
            file.close()
 
208
            # FIXME: We SHOULD send a Content-Range header too,
 
209
            # but the implementation of send_error does not
 
210
            # allows that. So far.
 
211
            self.send_error(416, "Requested range not satisfiable")
 
212
            return
 
213
 
 
214
        if len(ranges) == 1:
 
215
            (start, end) = ranges[0]
 
216
            self.get_single_range(file, file_size, start, end)
 
217
        else:
 
218
            self.get_multiple_ranges(file, file_size, ranges)
 
219
        file.close()
 
220
 
 
221
    if sys.platform == 'win32':
 
222
        # On win32 you cannot access non-ascii filenames without
 
223
        # decoding them into unicode first.
 
224
        # However, under Linux, you can access bytestream paths
 
225
        # without any problems. If this function was always active
 
226
        # it would probably break tests when LANG=C was set
 
227
        def translate_path(self, path):
 
228
            """Translate a /-separated PATH to the local filename syntax.
 
229
 
 
230
            For bzr, all url paths are considered to be utf8 paths.
 
231
            On Linux, you can access these paths directly over the bytestream
 
232
            request, but on win32, you must decode them, and access them
 
233
            as Unicode files.
 
234
            """
 
235
            # abandon query parameters
 
236
            path = urlparse.urlparse(path)[2]
 
237
            path = posixpath.normpath(urllib.unquote(path))
 
238
            path = path.decode('utf-8')
 
239
            words = path.split('/')
 
240
            words = filter(None, words)
 
241
            path = os.getcwdu()
 
242
            for word in words:
 
243
                drive, word = os.path.splitdrive(word)
 
244
                head, word = os.path.split(word)
 
245
                if word in (os.curdir, os.pardir): continue
 
246
                path = os.path.join(path, word)
 
247
            return path
 
248
 
 
249
 
 
250
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
 
251
 
 
252
    def __init__(self, server_address, RequestHandlerClass,
 
253
                 test_case_server):
 
254
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
 
255
                                           RequestHandlerClass)
 
256
        # test_case_server can be used to communicate between the
 
257
        # tests and the server (or the request handler and the
 
258
        # server), allowing dynamic behaviors to be defined from
 
259
        # the tests cases.
 
260
        self.test_case_server = test_case_server
 
261
 
 
262
 
 
263
class HttpServer(Server):
 
264
    """A test server for http transports.
 
265
 
 
266
    Subclasses can provide a specific request handler.
 
267
    """
 
268
 
 
269
    # used to form the url that connects to this server
 
270
    _url_protocol = 'http'
 
271
 
 
272
    # Subclasses can provide a specific request handler
 
273
    def __init__(self, request_handler=TestingHTTPRequestHandler):
 
274
        Server.__init__(self)
 
275
        self.request_handler = request_handler
 
276
        self.host = 'localhost'
 
277
        self.port = 0
 
278
        self._httpd = None
 
279
 
 
280
    def _get_httpd(self):
 
281
        if self._httpd is None:
 
282
            self._httpd = TestingHTTPServer((self.host, self.port),
 
283
                                            self.request_handler,
 
284
                                            self)
 
285
            host, self.port = self._httpd.socket.getsockname()
 
286
        return self._httpd
 
287
 
 
288
    def _http_start(self):
 
289
        httpd = self._get_httpd()
 
290
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
291
                                               self.host,
 
292
                                               self.port)
 
293
        self._http_starting.release()
 
294
        httpd.socket.settimeout(0.1)
 
295
 
 
296
        while self._http_running:
 
297
            try:
 
298
                httpd.handle_request()
 
299
            except socket.timeout:
 
300
                pass
 
301
 
 
302
    def _get_remote_url(self, path):
 
303
        path_parts = path.split(os.path.sep)
 
304
        if os.path.isabs(path):
 
305
            if path_parts[:len(self._local_path_parts)] != \
 
306
                   self._local_path_parts:
 
307
                raise BadWebserverPath(path, self.test_dir)
 
308
            remote_path = '/'.join(path_parts[len(self._local_path_parts):])
 
309
        else:
 
310
            remote_path = '/'.join(path_parts)
 
311
 
 
312
        return self._http_base_url + remote_path
 
313
 
 
314
    def log(self, format, *args):
 
315
        """Capture Server log output."""
 
316
        self.logs.append(format % args)
 
317
 
 
318
    def setUp(self):
 
319
        """See bzrlib.transport.Server.setUp."""
 
320
        self._home_dir = os.getcwdu()
 
321
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
322
        self._http_starting = threading.Lock()
 
323
        self._http_starting.acquire()
 
324
        self._http_running = True
 
325
        self._http_base_url = None
 
326
        self._http_thread = threading.Thread(target=self._http_start)
 
327
        self._http_thread.setDaemon(True)
 
328
        self._http_thread.start()
 
329
        # Wait for the server thread to start (i.e release the lock)
 
330
        self._http_starting.acquire()
 
331
        self._http_starting.release()
 
332
        self.logs = []
 
333
 
 
334
    def tearDown(self):
 
335
        """See bzrlib.transport.Server.tearDown."""
 
336
        self._http_running = False
 
337
        self._http_thread.join()
 
338
 
 
339
    def get_url(self):
 
340
        """See bzrlib.transport.Server.get_url."""
 
341
        return self._get_remote_url(self._home_dir)
 
342
 
 
343
    def get_bogus_url(self):
 
344
        """See bzrlib.transport.Server.get_bogus_url."""
 
345
        # this is chosen to try to prevent trouble with proxies, weird dns,
 
346
        # etc
 
347
        return 'http://127.0.0.1:1/'
 
348
 
 
349
 
 
350
class HttpServer_urllib(HttpServer):
 
351
    """Subclass of HttpServer that gives http+urllib urls.
 
352
 
 
353
    This is for use in testing: connections to this server will always go
 
354
    through urllib where possible.
 
355
    """
 
356
 
 
357
    # urls returned by this server should require the urllib client impl
 
358
    _url_protocol = 'http+urllib'
 
359
 
 
360
 
 
361
class HttpServer_PyCurl(HttpServer):
 
362
    """Subclass of HttpServer that gives http+pycurl urls.
 
363
 
 
364
    This is for use in testing: connections to this server will always go
 
365
    through pycurl where possible.
 
366
    """
 
367
 
 
368
    # We don't care about checking the pycurl availability as
 
369
    # this server will be required only when pycurl is present
 
370
 
 
371
    # urls returned by this server should require the pycurl client impl
 
372
    _url_protocol = 'http+pycurl'