← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/http/wsgi.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-06-05 02:46:38 UTC
  • mfrom: (4398.5.20 bencode_serializer)
  • Revision ID: pqm@pqm.ubuntu.com-20090605024638-fe5tn388osc38jvw
(bialix, jelmer, jam) Pyrex bencode and --development7-rich-root

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/http/wsgi.py
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
17
"""WSGI application for bzr HTTP smart server.
18
18
 
22
22
 
23
23
from cStringIO import StringIO
24
24
 
25
 
from bzrlib.transport import chroot, get_transport, remote
 
25
from bzrlib.smart import protocol, medium
 
26
from bzrlib.transport import chroot, get_transport
26
27
from bzrlib.urlutils import local_path_to_url
27
 
    
28
 
 
29
 
def make_app(root, prefix, path_var, readonly=True):
 
28
 
 
29
 
 
30
def make_app(root, prefix, path_var='REQUEST_URI', readonly=True,
 
31
    load_plugins=True, enable_logging=True):
30
32
    """Convenience function to construct a WSGI bzr smart server.
31
 
    
 
33
 
32
34
    :param root: a local path that requests will be relative to.
33
35
    :param prefix: See RelpathSetter.
34
36
    :param path_var: See RelpathSetter.
38
40
        base_transport = get_transport('readonly+' + local_url)
39
41
    else:
40
42
        base_transport = get_transport(local_url)
41
 
    app = SmartWSGIApp(base_transport)
42
 
    app = RelpathSetter(app, prefix, path_var)
 
43
    if load_plugins:
 
44
        from bzrlib.plugin import load_plugins
 
45
        load_plugins()
 
46
    if enable_logging:
 
47
        import bzrlib.trace
 
48
        bzrlib.trace.enable_default_logging()
 
49
    app = SmartWSGIApp(base_transport, prefix)
 
50
    app = RelpathSetter(app, '', path_var)
43
51
    return app
44
52
 
45
53
 
46
54
class RelpathSetter(object):
47
55
    """WSGI middleware to set 'bzrlib.relpath' in the environ.
48
 
    
 
56
 
49
57
    Different servers can invoke a SmartWSGIApp in different ways.  This
50
58
    middleware allows an adminstrator to configure how to the SmartWSGIApp will
51
59
    determine what path it should be serving for a given request for many common
57
65
    prefix="/some/prefix/" and path_var="REQUEST_URI" will set that request's
58
66
    'bzrlib.relpath' variable to "repo/branch".
59
67
    """
60
 
    
 
68
 
61
69
    def __init__(self, app, prefix='', path_var='REQUEST_URI'):
62
70
        """Constructor.
63
71
 
75
83
        path = environ[self.path_var]
76
84
        suffix = '/.bzr/smart'
77
85
        if not (path.startswith(self.prefix) and path.endswith(suffix)):
78
 
            start_response('404 Not Found', {})
 
86
            start_response('404 Not Found', [])
79
87
            return []
80
88
        environ['bzrlib.relpath'] = path[len(self.prefix):-len(suffix)]
81
89
        return self.app(environ, start_response)
84
92
class SmartWSGIApp(object):
85
93
    """A WSGI application for the bzr smart server."""
86
94
 
87
 
    def __init__(self, backing_transport):
 
95
    def __init__(self, backing_transport, root_client_path='/'):
88
96
        """Constructor.
89
97
 
90
98
        :param backing_transport: a transport.  Requests will be processed
91
99
            relative to this transport.
 
100
        :param root_client_path: the client path that maps to the root of
 
101
            backing_transport.  This is used to interpret relpaths received from
 
102
            the client.
92
103
        """
93
104
        # Use a ChrootTransportDecorator so that this web application won't
94
105
        # accidentally let people access locations they shouldn't.
97
108
        self.chroot_server = chroot.ChrootServer(backing_transport)
98
109
        self.chroot_server.setUp()
99
110
        self.backing_transport = get_transport(self.chroot_server.get_url())
 
111
        self.root_client_path = root_client_path
100
112
        # While the chroot server can technically be torn down at this point,
101
 
        # as all it does is remove the scheme registration from transport's 
102
 
        # protocol dictionary, we don't *just in case* there are parts of 
 
113
        # as all it does is remove the scheme registration from transport's
 
114
        # protocol dictionary, we don't *just in case* there are parts of
103
115
        # bzrlib that will invoke 'get_transport' on urls rather than cloning
104
116
        # around the existing transport.
105
117
        #self.chroot_server.tearDown()
111
123
            return []
112
124
 
113
125
        relpath = environ['bzrlib.relpath']
114
 
        transport = self.backing_transport.clone(relpath)
 
126
 
 
127
        if not relpath.startswith('/'):
 
128
            relpath = '/' + relpath
 
129
        if not relpath.endswith('/'):
 
130
            relpath += '/'
 
131
 
 
132
        # Compare the HTTP path (relpath) and root_client_path, and calculate
 
133
        # new relpath and root_client_path accordingly, to be used to build the
 
134
        # request.
 
135
        if relpath.startswith(self.root_client_path):
 
136
            # The relpath traverses all of the mandatory root client path.
 
137
            # Remove the root_client_path from the relpath, and set
 
138
            # adjusted_tcp to None to tell the request handler that no further
 
139
            # path translation is required.
 
140
            adjusted_rcp = None
 
141
            adjusted_relpath = relpath[len(self.root_client_path):]
 
142
        elif self.root_client_path.startswith(relpath):
 
143
            # The relpath traverses some of the mandatory root client path.
 
144
            # Subtract the relpath from the root_client_path, and set the
 
145
            # relpath to '.'.
 
146
            adjusted_rcp = '/' + self.root_client_path[len(relpath):]
 
147
            adjusted_relpath = '.'
 
148
        else:
 
149
            adjusted_rcp = self.root_client_path
 
150
            adjusted_relpath = relpath
 
151
 
 
152
        if adjusted_relpath.startswith('/'):
 
153
            adjusted_relpath = adjusted_relpath[1:]
 
154
        if adjusted_relpath.startswith('/'):
 
155
            raise AssertionError(adjusted_relpath)
 
156
 
 
157
        transport = self.backing_transport.clone(adjusted_relpath)
115
158
        out_buffer = StringIO()
116
 
        smart_protocol_request = self.make_request(transport, out_buffer.write)
117
159
        request_data_length = int(environ['CONTENT_LENGTH'])
118
160
        request_data_bytes = environ['wsgi.input'].read(request_data_length)
119
 
        smart_protocol_request.accept_bytes(request_data_bytes)
 
161
        smart_protocol_request = self.make_request(
 
162
            transport, out_buffer.write, request_data_bytes, adjusted_rcp)
120
163
        if smart_protocol_request.next_read_size() != 0:
121
164
            # The request appears to be incomplete, or perhaps it's just a
122
165
            # newer version we don't understand.  Regardless, all we can do
130
173
        start_response('200 OK', headers)
131
174
        return [response_data]
132
175
 
133
 
    def make_request(self, transport, write_func):
134
 
        return protocol.SmartServerRequestProtocolOne(transport, write_func)
 
176
    def make_request(self, transport, write_func, request_bytes, rcp):
 
177
        protocol_factory, unused_bytes = medium._get_protocol_factory_for_bytes(
 
178
            request_bytes)
 
179
        server_protocol = protocol_factory(transport, write_func, rcp)
 
180
        server_protocol.accept_bytes(unused_bytes)
 
181
        return server_protocol