← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/apps/transport.py

  • Committer: Michael Hudson-Doyle
  • Date: 2012-01-08 22:04:51 UTC
  • mto: This revision was merged to the branch mainline in revision 464.
  • Revision ID: michael.hudson@linaro.org-20120108220451-kepgk6pfh59cze8a
this should fix the bug, but i cannot reproduce it locally

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/apps/transport.py
1
 
"""Serve branches at urls that mimic the file system layout."""
2
 
 
3
 
import os
4
 
import tempfile
5
 
 
6
 
from bzrlib import branch, errors, lru_cache
 
1
# Copyright (C) 2008-2011 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
"""Serve branches at urls that mimic a transport's file system layout."""
 
18
 
 
19
import threading
 
20
 
 
21
from bzrlib import branch, errors, lru_cache, urlutils
 
22
from bzrlib.config import LocationConfig
 
23
from bzrlib.smart import request
 
24
from bzrlib.transport import get_transport
 
25
from bzrlib.transport.http import wsgi
7
26
 
8
27
from paste.request import path_info_pop
9
28
from paste import httpexceptions
 
29
from paste import urlparser
10
30
 
 
31
from loggerhead import util
11
32
from loggerhead.apps.branch import BranchWSGIApp
12
 
from loggerhead.apps import favicon_app, static_app
 
33
from loggerhead.apps import favicon_app, robots_app, static_app
13
34
from loggerhead.controllers.directory_ui import DirectoryUI
14
35
 
15
 
sql_dir = tempfile.mkdtemp(prefix='loggerhead-cache-')
16
 
 
17
 
 
18
 
class BranchesFromFileSystemServer(object):
19
 
 
20
 
    def __init__(self, path, root, name=None):
21
 
        self.path = path
 
36
# TODO: Use bzrlib.ui.bool_from_string(), added in bzr 1.18
 
37
_bools = {
 
38
    'yes': True, 'no': False,
 
39
    'on': True, 'off': False,
 
40
    '1': True, '0': False,
 
41
    'true': True, 'false': False,
 
42
    }
 
43
 
 
44
class BranchesFromTransportServer(object):
 
45
 
 
46
    def __init__(self, transport, root, name=None):
 
47
        self.transport = transport
22
48
        self.root = root
23
49
        self.name = name
 
50
        self._config = root._config
24
51
 
25
52
    def app_for_branch(self, branch):
26
53
        if not self.name:
27
 
            name = branch.nick
 
54
            name = branch._get_nick(local=True)
28
55
            is_root = True
29
56
        else:
30
57
            name = self.name
31
58
            is_root = False
32
59
        branch_app = BranchWSGIApp(
33
 
            branch, name, {'cachepath': sql_dir}, self.root.graph_cache,
34
 
            is_root=is_root)
 
60
            branch,
 
61
            name,
 
62
            {'cachepath': self._config.SQL_DIR},
 
63
            self.root.graph_cache,
 
64
            is_root=is_root,
 
65
            use_cdn=self._config.get_option('use_cdn'),
 
66
            )
35
67
        return branch_app.app
36
68
 
37
69
    def app_for_non_branch(self, environ):
38
70
        segment = path_info_pop(environ)
39
71
        if segment is None:
40
 
            raise httpexceptions.HTTPMovedPermanently(
41
 
                environ['SCRIPT_NAME'] + '/')
 
72
            raise httpexceptions.HTTPMovedPermanently.relative_redirect(
 
73
                environ['SCRIPT_NAME'] + '/', environ)
42
74
        elif segment == '':
43
75
            if self.name:
44
76
                name = self.name
45
77
            else:
46
78
                name = '/'
47
 
            return DirectoryUI(environ['loggerhead.static.url'],
48
 
                               self.path,
49
 
                               name)
 
79
            return DirectoryUI(
 
80
                environ['loggerhead.static.url'], self.transport, name)
50
81
        else:
51
 
            new_path = os.path.join(self.path, segment)
 
82
            new_transport = self.transport.clone(segment)
52
83
            if self.name:
53
 
                new_name = os.path.join(self.name, segment)
 
84
                new_name = urlutils.join(self.name, segment)
54
85
            else:
55
86
                new_name = '/' + segment
56
 
            return BranchesFromFileSystemServer(new_path, self.root, new_name)
57
 
 
58
 
    def __call__(self, environ, start_response):
59
 
        if not os.path.isdir(self.path):
 
87
            return BranchesFromTransportServer(new_transport, self.root, new_name)
 
88
 
 
89
    def app_for_bazaar_data(self, relpath):
 
90
        if relpath == '/.bzr/smart':
 
91
            root_transport = get_transport_for_thread(self.root.base)
 
92
            wsgi_app = wsgi.SmartWSGIApp(root_transport)
 
93
            return wsgi.RelpathSetter(wsgi_app, '', 'loggerhead.path_info')
 
94
        else:
 
95
            # TODO: Use something here that uses the transport API
 
96
            # rather than relying on the local filesystem API.
 
97
            base = self.transport.base
 
98
            try:
 
99
                path = util.local_path_from_url(base)
 
100
            except errors.InvalidURL:
 
101
                raise httpexceptions.HTTPNotFound()
 
102
            else:
 
103
                return urlparser.make_static(None, path)
 
104
 
 
105
    def check_serveable(self, config):
 
106
        value = config.get_user_option('http_serve')
 
107
        if value is None:
 
108
            return
 
109
        elif not _bools.get(value.lower(), True):
60
110
            raise httpexceptions.HTTPNotFound()
 
111
 
 
112
    def __call__(self, environ, start_response):
 
113
        path = environ['PATH_INFO']
61
114
        try:
62
 
            b = branch.Branch.open(self.path)
 
115
            b = branch.Branch.open_from_transport(self.transport)
63
116
        except errors.NotBranchError:
 
117
            if path.startswith('/.bzr'):
 
118
                self.check_serveable(LocationConfig(self.transport.base))
 
119
                return self.app_for_bazaar_data(path)(environ, start_response)
 
120
            if not self.transport.listable() or not self.transport.has('.'):
 
121
                raise httpexceptions.HTTPNotFound()
64
122
            return self.app_for_non_branch(environ)(environ, start_response)
65
123
        else:
66
 
            return self.app_for_branch(b)(environ, start_response)
67
 
 
68
 
 
69
 
class BranchesFromFileSystemRoot(object):
70
 
 
71
 
    def __init__(self, folder):
72
 
        self.graph_cache = lru_cache.LRUCache()
73
 
        self.folder = folder
 
124
            self.check_serveable(b.get_config())
 
125
            if path.startswith('/.bzr'):
 
126
                return self.app_for_bazaar_data(path)(environ, start_response)
 
127
            else:
 
128
                return self.app_for_branch(b)(environ, start_response)
 
129
 
 
130
 
 
131
_transport_store = threading.local()
 
132
 
 
133
def get_transport_for_thread(base):
 
134
    thread_transports = getattr(_transport_store, 'transports', None)
 
135
    if thread_transports is None:
 
136
        thread_transports = _transport_store.transports = {}
 
137
    if base in thread_transports:
 
138
        return thread_transports[base]
 
139
    transport = get_transport(base)
 
140
    thread_transports[base] = transport
 
141
    return transport
 
142
 
 
143
 
 
144
class BranchesFromTransportRoot(object):
 
145
 
 
146
    def __init__(self, base, config):
 
147
        self.graph_cache = lru_cache.LRUCache(10)
 
148
        self.base = base
 
149
        self._config = config
74
150
 
75
151
    def __call__(self, environ, start_response):
76
152
        environ['loggerhead.static.url'] = environ['SCRIPT_NAME']
 
153
        environ['loggerhead.path_info'] = environ['PATH_INFO']
77
154
        if environ['PATH_INFO'].startswith('/static/'):
78
155
            segment = path_info_pop(environ)
79
156
            assert segment == 'static'
80
157
            return static_app(environ, start_response)
81
158
        elif environ['PATH_INFO'] == '/favicon.ico':
82
159
            return favicon_app(environ, start_response)
 
160
        elif environ['PATH_INFO'] == '/robots.txt':
 
161
            return robots_app(environ, start_response)
83
162
        else:
84
 
            return BranchesFromFileSystemServer(
85
 
                self.folder, self)(environ, start_response)
86
 
 
87
 
 
88
 
class UserBranchesFromFileSystemRoot(object):
89
 
 
90
 
    def __init__(self, folder, trunk_dir):
91
 
        self.graph_cache = lru_cache.LRUCache()
92
 
        self.folder = folder
93
 
        self.trunk_dir = trunk_dir
 
163
            transport = get_transport_for_thread(self.base)
 
164
            return BranchesFromTransportServer(
 
165
                transport, self)(environ, start_response)
 
166
 
 
167
 
 
168
class UserBranchesFromTransportRoot(object):
 
169
 
 
170
    def __init__(self, base, config):
 
171
        self.graph_cache = lru_cache.LRUCache(10)
 
172
        self.base = base
 
173
        self._config = config
 
174
        self.trunk_dir = config.get_option('trunk_dir')
94
175
 
95
176
    def __call__(self, environ, start_response):
96
177
        environ['loggerhead.static.url'] = environ['SCRIPT_NAME']
97
 
        path_info= environ['PATH_INFO']
 
178
        environ['loggerhead.path_info'] = environ['PATH_INFO']
 
179
        path_info = environ['PATH_INFO']
98
180
        if path_info.startswith('/static/'):
99
181
            segment = path_info_pop(environ)
100
182
            assert segment == 'static'
101
183
            return static_app(environ, start_response)
102
184
        elif path_info == '/favicon.ico':
103
185
            return favicon_app(environ, start_response)
 
186
        elif environ['PATH_INFO'] == '/robots.txt':
 
187
            return robots_app(environ, start_response)
104
188
        else:
 
189
            transport = get_transport_for_thread(self.base)
105
190
            # segments starting with ~ are user branches
106
191
            if path_info.startswith('/~'):
107
192
                segment = path_info_pop(environ)
108
 
                new_path = os.path.join(self.folder, segment[1:])
109
 
                return BranchesFromFileSystemServer(
110
 
                    new_path, self, segment)(environ, start_response)
 
193
                return BranchesFromTransportServer(
 
194
                    transport.clone(segment[1:]), self, segment)(
 
195
                    environ, start_response)
111
196
            else:
112
 
                new_path = os.path.join(self.folder, self.trunk_dir)
113
 
                return BranchesFromFileSystemServer(
114
 
                    new_path, self)(environ, start_response)
 
197
                return BranchesFromTransportServer(
 
198
                    transport.clone(self.trunk_dir), self)(
 
199
                    environ, start_response)