← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_utils.py

  • Committer: Martin Pool
  • Date: 2008-05-08 04:12:06 UTC
  • mto: This revision was merged to the branch mainline in revision 3415.
  • Revision ID: mbp@sourcefrog.net-20080508041206-tkrr8ucmcyrlzkum
Some review cleanups for assertion removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_utils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005 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
17
from cStringIO import StringIO
18
18
import errno
 
19
import md5
19
20
import re
 
21
import sha
20
22
import socket
21
23
import threading
22
24
import time
23
25
import urllib2
24
26
import urlparse
25
27
 
26
 
 
27
28
from bzrlib import (
28
29
    errors,
29
 
    osutils,
30
30
    tests,
 
31
    transport,
31
32
    )
32
 
from bzrlib.smart import medium, protocol
 
33
from bzrlib.smart import protocol
33
34
from bzrlib.tests import http_server
34
 
from bzrlib.transport import (
35
 
    chroot,
36
 
    get_transport,
37
 
    )
38
35
 
39
36
 
40
37
class HTTPServerWithSmarts(http_server.HttpServer):
49
46
 
50
47
 
51
48
class SmartRequestHandler(http_server.TestingHTTPRequestHandler):
52
 
    """Extend TestingHTTPRequestHandler to support smart client POSTs.
53
 
 
54
 
    XXX: This duplicates a fair bit of the logic in bzrlib.transport.http.wsgi.
55
 
    """
 
49
    """Extend TestingHTTPRequestHandler to support smart client POSTs."""
56
50
 
57
51
    def do_POST(self):
58
52
        """Hand the request off to a smart server instance."""
59
 
        backing = get_transport(self.server.test_case_server._home_dir)
60
 
        chroot_server = chroot.ChrootServer(backing)
61
 
        chroot_server.start_server()
62
 
        try:
63
 
            t = get_transport(chroot_server.get_url())
64
 
            self.do_POST_inner(t)
65
 
        finally:
66
 
            chroot_server.stop_server()
67
 
 
68
 
    def do_POST_inner(self, chrooted_transport):
69
53
        self.send_response(200)
70
54
        self.send_header("Content-type", "application/octet-stream")
71
 
        if not self.path.endswith('.bzr/smart'):
72
 
            raise AssertionError(
73
 
                'POST to path not ending in .bzr/smart: %r' % (self.path,))
74
 
        t = chrooted_transport.clone(self.path[:-len('.bzr/smart')])
75
 
        # if this fails, we should return 400 bad request, but failure is
76
 
        # failure for now - RBC 20060919
77
 
        data_length = int(self.headers['Content-Length'])
 
55
        t = transport.get_transport(self.server.test_case_server._home_dir)
78
56
        # TODO: We might like to support streaming responses.  1.0 allows no
79
57
        # Content-length in this case, so for integrity we should perform our
80
58
        # own chunking within the stream.
82
60
        # the HTTP chunking as this will allow HTTP persistence safely, even if
83
61
        # we have to stop early due to error, but we would also have to use the
84
62
        # HTTP trailer facility which may not be widely available.
85
 
        request_bytes = self.rfile.read(data_length)
86
 
        protocol_factory, unused_bytes = medium._get_protocol_factory_for_bytes(
87
 
            request_bytes)
88
63
        out_buffer = StringIO()
89
 
        smart_protocol_request = protocol_factory(t, out_buffer.write, '/')
 
64
        smart_protocol_request = protocol.SmartServerRequestProtocolOne(
 
65
                t, out_buffer.write)
 
66
        # if this fails, we should return 400 bad request, but failure is
 
67
        # failure for now - RBC 20060919
 
68
        data_length = int(self.headers['Content-Length'])
90
69
        # Perhaps there should be a SmartServerHTTPMedium that takes care of
91
70
        # feeding the bytes in the http request to the smart_protocol_request,
92
71
        # but for now it's simpler to just feed the bytes directly.
93
 
        smart_protocol_request.accept_bytes(unused_bytes)
 
72
        smart_protocol_request.accept_bytes(self.rfile.read(data_length))
94
73
        if not (smart_protocol_request.next_read_size() == 0):
95
74
            raise errors.SmartProtocolError(
96
75
                "not finished reading, but all data sent to protocol.")
133
112
        """Get the server instance for the secondary transport."""
134
113
        if self.__secondary_server is None:
135
114
            self.__secondary_server = self.create_transport_secondary_server()
136
 
            self.start_server(self.__secondary_server)
 
115
            self.__secondary_server.setUp()
 
116
            self.addCleanup(self.__secondary_server.tearDown)
137
117
        return self.__secondary_server
138
118
 
139
119
 
296
276
 
297
277
    def authorized(self):
298
278
        tcs = self.server.test_case_server
 
279
        if tcs.auth_scheme != 'digest':
 
280
            return False
299
281
 
300
282
        auth_header = self.headers.get(tcs.auth_header_recv, None)
301
283
        if auth_header is None:
316
298
        self.send_header(tcs.auth_header_sent,header)
317
299
 
318
300
 
319
 
class DigestAndBasicAuthRequestHandler(DigestAuthRequestHandler):
320
 
    """Implements a digest and basic authentication of a request.
321
 
 
322
 
    I.e. the server proposes both schemes and the client should choose the best
323
 
    one it can handle, which, in that case, should be digest, the only scheme
324
 
    accepted here.
325
 
    """
326
 
 
327
 
    def send_header_auth_reqed(self):
328
 
        tcs = self.server.test_case_server
329
 
        self.send_header(tcs.auth_header_sent,
330
 
                         'Basic realm="%s"' % tcs.auth_realm)
331
 
        header = 'Digest realm="%s", ' % tcs.auth_realm
332
 
        header += 'nonce="%s", algorithm="%s", qop="auth"' % (tcs.auth_nonce,
333
 
                                                              'MD5')
334
 
        self.send_header(tcs.auth_header_sent,header)
335
 
 
336
 
 
337
301
class AuthServer(http_server.HttpServer):
338
302
    """Extends HttpServer with a dictionary of passwords.
339
303
 
412
376
        A1 = '%s:%s:%s' % (user, realm, password)
413
377
        A2 = '%s:%s' % (command, auth['uri'])
414
378
 
415
 
        H = lambda x: osutils.md5(x).hexdigest()
 
379
        H = lambda x: md5.new(x).hexdigest()
416
380
        KD = lambda secret, data: H("%s:%s" % (secret, data))
417
381
 
418
382
        nonce_count = int(auth['nc'], 16)
425
389
 
426
390
        return response_digest == auth['response']
427
391
 
428
 
 
429
392
class HTTPAuthServer(AuthServer):
430
393
    """An HTTP server requiring authentication"""
431
394
 
463
426
        self.init_http_auth()
464
427
 
465
428
 
466
 
class HTTPBasicAndDigestAuthServer(DigestAuthServer, HTTPAuthServer):
467
 
    """An HTTP server requiring basic or digest authentication"""
468
 
 
469
 
    def __init__(self, protocol_version=None):
470
 
        DigestAuthServer.__init__(self, DigestAndBasicAuthRequestHandler,
471
 
                                  'basicdigest',
472
 
                                  protocol_version=protocol_version)
473
 
        self.init_http_auth()
474
 
        # We really accept Digest only
475
 
        self.auth_scheme = 'digest'
476
 
 
477
 
 
478
429
class ProxyBasicAuthServer(ProxyAuthServer):
479
430
    """A proxy server requiring basic authentication"""
480
431
 
493
444
        self.init_proxy_auth()
494
445
 
495
446
 
496
 
class ProxyBasicAndDigestAuthServer(DigestAuthServer, ProxyAuthServer):
497
 
    """An proxy server requiring basic or digest authentication"""
498
 
 
499
 
    def __init__(self, protocol_version=None):
500
 
        DigestAuthServer.__init__(self, DigestAndBasicAuthRequestHandler,
501
 
                                  'basicdigest',
502
 
                                  protocol_version=protocol_version)
503
 
        self.init_proxy_auth()
504
 
        # We really accept Digest only
505
 
        self.auth_scheme = 'digest'
506
 
 
507