1
# Copyright (C) 2005 Canonical Ltd
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.
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.
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
17
from cStringIO import StringIO
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
28
from bzrlib.smart import protocol
29
from bzrlib.tests import TestCaseWithTransport
30
from bzrlib.tests.HttpServer import (
32
TestingHTTPRequestHandler,
34
from bzrlib.transport import (
39
class WallRequestHandler(TestingHTTPRequestHandler):
40
"""Whatever request comes in, close the connection"""
42
def handle_one_request(self):
43
"""Handle a single HTTP request, by abruptly closing the connection"""
44
self.close_connection = 1
47
class BadStatusRequestHandler(TestingHTTPRequestHandler):
48
"""Whatever request comes in, returns a bad status"""
50
def parse_request(self):
51
"""Fakes handling a single HTTP request, returns a bad status"""
52
ignored = TestingHTTPRequestHandler.parse_request(self)
54
self.send_response(0, "Bad status")
56
except socket.error, e:
57
# We don't want to pollute the test results with
58
# spurious server errors while test succeed. In our
59
# case, it may occur that the test has already read
60
# the 'Bad Status' and closed the socket while we are
61
# still trying to send some headers... So the test is
62
# ok, but if we raise the exception, the output is
63
# dirty. So we don't raise, but we close the
64
# connection, just to be safe :)
65
spurious = [errno.EPIPE,
69
if (len(e.args) > 0) and (e.args[0] in spurious):
70
self.close_connection = 1
77
class InvalidStatusRequestHandler(TestingHTTPRequestHandler):
78
"""Whatever request comes in, returns am invalid status"""
80
def parse_request(self):
81
"""Fakes handling a single HTTP request, returns a bad status"""
82
ignored = TestingHTTPRequestHandler.parse_request(self)
83
self.wfile.write("Invalid status line\r\n")
87
class BadProtocolRequestHandler(TestingHTTPRequestHandler):
88
"""Whatever request comes in, returns a bad protocol version"""
90
def parse_request(self):
91
"""Fakes handling a single HTTP request, returns a bad status"""
92
ignored = TestingHTTPRequestHandler.parse_request(self)
93
# Returns an invalid protocol version, but curl just
94
# ignores it and those cannot be tested.
95
self.wfile.write("%s %d %s\r\n" % ('HTTP/0.0',
97
'Look at my protocol version'))
101
class ForbiddenRequestHandler(TestingHTTPRequestHandler):
102
"""Whatever request comes in, returns a 403 code"""
104
def parse_request(self):
105
"""Handle a single HTTP request, by replying we cannot handle it"""
106
ignored = TestingHTTPRequestHandler.parse_request(self)
111
class HTTPServerWithSmarts(HttpServer):
112
"""HTTPServerWithSmarts extends the HttpServer with POST methods that will
113
trigger a smart server to execute with a transport rooted at the rootdir of
118
HttpServer.__init__(self, SmartRequestHandler)
121
class SmartRequestHandler(TestingHTTPRequestHandler):
122
"""Extend TestingHTTPRequestHandler to support smart client POSTs."""
125
"""Hand the request off to a smart server instance."""
126
self.send_response(200)
127
self.send_header("Content-type", "application/octet-stream")
128
transport = get_transport(self.server.test_case_server._home_dir)
129
# TODO: We might like to support streaming responses. 1.0 allows no
130
# Content-length in this case, so for integrity we should perform our
131
# own chunking within the stream.
132
# 1.1 allows chunked responses, and in this case we could chunk using
133
# the HTTP chunking as this will allow HTTP persistence safely, even if
134
# we have to stop early due to error, but we would also have to use the
135
# HTTP trailer facility which may not be widely available.
136
out_buffer = StringIO()
137
smart_protocol_request = protocol.SmartServerRequestProtocolOne(
138
transport, out_buffer.write)
139
# if this fails, we should return 400 bad request, but failure is
140
# failure for now - RBC 20060919
141
data_length = int(self.headers['Content-Length'])
142
# Perhaps there should be a SmartServerHTTPMedium that takes care of
143
# feeding the bytes in the http request to the smart_protocol_request,
144
# but for now it's simpler to just feed the bytes directly.
145
smart_protocol_request.accept_bytes(self.rfile.read(data_length))
146
assert smart_protocol_request.next_read_size() == 0, (
147
"not finished reading, but all data sent to protocol.")
148
self.send_header("Content-Length", str(len(out_buffer.getvalue())))
150
self.wfile.write(out_buffer.getvalue())
153
class LimitedRangeRequestHandler(TestingHTTPRequestHandler):
154
"""Errors out when range specifiers exceed the limit"""
156
def get_multiple_ranges(self, file, file_size, ranges):
157
"""Refuses the multiple ranges request"""
158
tcs = self.server.test_case_server
159
if tcs.range_limit is not None and len(ranges) > tcs.range_limit:
161
# Emulate apache behavior
162
self.send_error(400, "Bad Request")
164
return TestingHTTPRequestHandler.get_multiple_ranges(self, file,
168
class LimitedRangeHTTPServer(HttpServer):
169
"""An HttpServer erroring out on requests with too much range specifiers"""
171
def __init__(self, request_handler=LimitedRangeRequestHandler,
173
HttpServer.__init__(self, request_handler)
174
self.range_limit = range_limit
177
class SingleRangeRequestHandler(TestingHTTPRequestHandler):
178
"""Always reply to range request as if they were single.
180
Don't be explicit about it, just to annoy the clients.
183
def get_multiple_ranges(self, file, file_size, ranges):
184
"""Answer as if it was a single range request and ignores the rest"""
185
(start, end) = ranges[0]
186
return self.get_single_range(file, file_size, start, end)
189
class SingleOnlyRangeRequestHandler(TestingHTTPRequestHandler):
190
"""Only reply to simple range requests, errors out on multiple"""
192
def get_multiple_ranges(self, file, file_size, ranges):
193
"""Refuses the multiple ranges request"""
196
self.send_error(416, "Requested range not satisfiable")
198
(start, end) = ranges[0]
199
return self.get_single_range(file, file_size, start, end)
202
class NoRangeRequestHandler(TestingHTTPRequestHandler):
203
"""Ignore range requests without notice"""
206
# Update the statistics
207
self.server.test_case_server.GET_request_nb += 1
208
# Just bypass the range handling done by TestingHTTPRequestHandler
209
return SimpleHTTPRequestHandler.do_GET(self)
212
class TestCaseWithWebserver(TestCaseWithTransport):
213
"""A support class that provides readonly urls that are http://.
215
This is done by forcing the readonly server to be an http
216
one. This will currently fail if the primary transport is not
217
backed by regular disk files.
220
super(TestCaseWithWebserver, self).setUp()
221
self.transport_readonly_server = HttpServer
224
class TestCaseWithTwoWebservers(TestCaseWithWebserver):
225
"""A support class providing readonly urls on two servers that are http://.
227
We set up two webservers to allows various tests involving
228
proxies or redirections from one server to the other.
231
super(TestCaseWithTwoWebservers, self).setUp()
232
self.transport_secondary_server = HttpServer
233
self.__secondary_server = None
235
def create_transport_secondary_server(self):
236
"""Create a transport server from class defined at init.
238
This is mostly a hook for daughter classes.
240
return self.transport_secondary_server()
242
def get_secondary_server(self):
243
"""Get the server instance for the secondary transport."""
244
if self.__secondary_server is None:
245
self.__secondary_server = self.create_transport_secondary_server()
246
self.__secondary_server.setUp()
247
self.addCleanup(self.__secondary_server.tearDown)
248
return self.__secondary_server
251
class ProxyServer(HttpServer):
252
"""A proxy test server for http transports."""
254
proxy_requests = True
257
class RedirectRequestHandler(TestingHTTPRequestHandler):
258
"""Redirect all request to the specified server"""
260
def parse_request(self):
261
"""Redirect a single HTTP request to another host"""
262
valid = TestingHTTPRequestHandler.parse_request(self)
264
tcs = self.server.test_case_server
265
code, target = tcs.is_redirected(self.path)
266
if code is not None and target is not None:
267
# Redirect as instructed
268
self.send_response(code)
269
self.send_header('Location', target)
271
return False # The job is done
273
# We leave the parent class serve the request
278
class HTTPServerRedirecting(HttpServer):
279
"""An HttpServer redirecting to another server """
281
def __init__(self, request_handler=RedirectRequestHandler):
282
HttpServer.__init__(self, request_handler)
283
# redirections is a list of tuples (source, target, code)
284
# - source is a regexp for the paths requested
285
# - target is a replacement for re.sub describing where
286
# the request will be redirected
287
# - code is the http error code associated to the
288
# redirection (301 permanent, 302 temporarry, etc
289
self.redirections = []
291
def redirect_to(self, host, port):
292
"""Redirect all requests to a specific host:port"""
293
self.redirections = [('(.*)',
294
r'http://%s:%s\1' % (host, port) ,
297
def is_redirected(self, path):
298
"""Is the path redirected by this server.
300
:param path: the requested relative path
302
:returns: a tuple (code, target) if a matching
303
redirection is found, (None, None) otherwise.
307
for (rsource, rtarget, rcode) in self.redirections:
308
target, match = re.subn(rsource, rtarget, path)
311
break # The first match wins
317
class TestCaseWithRedirectedWebserver(TestCaseWithTwoWebservers):
318
"""A support class providing redirections from one server to another.
320
We set up two webservers to allows various tests involving
322
The 'old' server is redirected to the 'new' server.
325
def create_transport_secondary_server(self):
326
"""Create the secondary server redirecting to the primary server"""
327
new = self.get_readonly_server()
328
redirecting = HTTPServerRedirecting()
329
redirecting.redirect_to(new.host, new.port)
333
super(TestCaseWithRedirectedWebserver, self).setUp()
334
# The redirections will point to the new server
335
self.new_server = self.get_readonly_server()
336
# The requests to the old server will be redirected
337
self.old_server = self.get_secondary_server()
340
class AuthRequestHandler(TestingHTTPRequestHandler):
341
"""Requires an authentication to process requests.
343
This is intended to be used with a server that always and
344
only use one authentication scheme (implemented by daughter
348
# The following attributes should be defined in the server
349
# - auth_header_sent: the header name sent to require auth
350
# - auth_header_recv: the header received containing auth
351
# - auth_error_code: the error code to indicate auth required
354
if self.authorized():
355
return TestingHTTPRequestHandler.do_GET(self)
357
# Note that we must update test_case_server *before*
358
# sending the error or the client may try to read it
359
# before we have sent the whole error back.
360
tcs = self.server.test_case_server
361
tcs.auth_required_errors += 1
362
self.send_response(tcs.auth_error_code)
363
self.send_header_auth_reqed()
368
class BasicAuthRequestHandler(AuthRequestHandler):
369
"""Implements the basic authentication of a request"""
371
def authorized(self):
372
tcs = self.server.test_case_server
373
if tcs.auth_scheme != 'basic':
376
auth_header = self.headers.get(tcs.auth_header_recv, None)
378
scheme, raw_auth = auth_header.split(' ', 1)
379
if scheme.lower() == tcs.auth_scheme:
380
user, password = raw_auth.decode('base64').split(':')
381
return tcs.authorized(user, password)
385
def send_header_auth_reqed(self):
386
tcs = self.server.test_case_server
387
self.send_header(tcs.auth_header_sent,
388
'Basic realm="%s"' % tcs.auth_realm)
391
# FIXME: We could send an Authentication-Info header too when
392
# the authentication is succesful
394
class DigestAuthRequestHandler(AuthRequestHandler):
395
"""Implements the digest authentication of a request.
397
We need persistence for some attributes and that can't be
398
achieved here since we get instantiated for each request. We
399
rely on the DigestAuthServer to take care of them.
402
def authorized(self):
403
tcs = self.server.test_case_server
404
if tcs.auth_scheme != 'digest':
407
auth_header = self.headers.get(tcs.auth_header_recv, None)
408
if auth_header is None:
410
scheme, auth = auth_header.split(None, 1)
411
if scheme.lower() == tcs.auth_scheme:
412
auth_dict = urllib2.parse_keqv_list(urllib2.parse_http_list(auth))
414
return tcs.digest_authorized(auth_dict, self.command)
418
def send_header_auth_reqed(self):
419
tcs = self.server.test_case_server
420
header = 'Digest realm="%s", ' % tcs.auth_realm
421
header += 'nonce="%s", algorithm="%s", qop="auth"' % (tcs.auth_nonce,
423
self.send_header(tcs.auth_header_sent,header)
426
class AuthServer(HttpServer):
427
"""Extends HttpServer with a dictionary of passwords.
429
This is used as a base class for various schemes which should
430
all use or redefined the associated AuthRequestHandler.
432
Note that no users are defined by default, so add_user should
433
be called before issuing the first request.
436
# The following attributes should be set dy daughter classes
437
# and are used by AuthRequestHandler.
438
auth_header_sent = None
439
auth_header_recv = None
440
auth_error_code = None
441
auth_realm = "Thou should not pass"
443
def __init__(self, request_handler, auth_scheme):
444
HttpServer.__init__(self, request_handler)
445
self.auth_scheme = auth_scheme
446
self.password_of = {}
447
self.auth_required_errors = 0
449
def add_user(self, user, password):
450
"""Declare a user with an associated password.
452
password can be empty, use an empty string ('') in that
455
self.password_of[user] = password
457
def authorized(self, user, password):
458
"""Check that the given user provided the right password"""
459
expected_password = self.password_of.get(user, None)
460
return expected_password is not None and password == expected_password
463
# FIXME: There is some code duplication with
464
# _urllib2_wrappers.py.DigestAuthHandler. If that duplication
465
# grows, it may require a refactoring. Also, we don't implement
466
# SHA algorithm nor MD5-sess here, but that does not seem worth
468
class DigestAuthServer(AuthServer):
469
"""A digest authentication server"""
473
def __init__(self, request_handler, auth_scheme):
474
AuthServer.__init__(self, request_handler, auth_scheme)
476
def digest_authorized(self, auth, command):
477
nonce = auth['nonce']
478
if nonce != self.auth_nonce:
480
realm = auth['realm']
481
if realm != self.auth_realm:
483
user = auth['username']
484
if not self.password_of.has_key(user):
486
algorithm= auth['algorithm']
487
if algorithm != 'MD5':
493
password = self.password_of[user]
495
# Recalculate the response_digest to compare with the one
497
A1 = '%s:%s:%s' % (user, realm, password)
498
A2 = '%s:%s' % (command, auth['uri'])
500
H = lambda x: md5.new(x).hexdigest()
501
KD = lambda secret, data: H("%s:%s" % (secret, data))
503
nonce_count = int(auth['nc'], 16)
505
ncvalue = '%08x' % nonce_count
507
cnonce = auth['cnonce']
508
noncebit = '%s:%s:%s:%s:%s' % (nonce, ncvalue, cnonce, qop, H(A2))
509
response_digest = KD(H(A1), noncebit)
511
return response_digest == auth['response']
513
class HTTPAuthServer(AuthServer):
514
"""An HTTP server requiring authentication"""
516
def init_http_auth(self):
517
self.auth_header_sent = 'WWW-Authenticate'
518
self.auth_header_recv = 'Authorization'
519
self.auth_error_code = 401
522
class ProxyAuthServer(AuthServer):
523
"""A proxy server requiring authentication"""
525
def init_proxy_auth(self):
526
self.proxy_requests = True
527
self.auth_header_sent = 'Proxy-Authenticate'
528
self.auth_header_recv = 'Proxy-Authorization'
529
self.auth_error_code = 407
532
class HTTPBasicAuthServer(HTTPAuthServer):
533
"""An HTTP server requiring basic authentication"""
536
HTTPAuthServer.__init__(self, BasicAuthRequestHandler, 'basic')
537
self.init_http_auth()
540
class HTTPDigestAuthServer(DigestAuthServer, HTTPAuthServer):
541
"""An HTTP server requiring digest authentication"""
544
DigestAuthServer.__init__(self, DigestAuthRequestHandler, 'digest')
545
self.init_http_auth()
548
class ProxyBasicAuthServer(ProxyAuthServer):
549
"""A proxy server requiring basic authentication"""
552
ProxyAuthServer.__init__(self, BasicAuthRequestHandler, 'basic')
553
self.init_proxy_auth()
556
class ProxyDigestAuthServer(DigestAuthServer, ProxyAuthServer):
557
"""A proxy server requiring basic authentication"""
560
ProxyAuthServer.__init__(self, DigestAuthRequestHandler, 'digest')
561
self.init_proxy_auth()
added
removed
bzrlib/tests/HTTPTestUtil.py
