~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remotebranch.py

  • Committer: Robert Collins
  • Date: 2005-10-02 01:53:46 UTC
  • mfrom: (1393.1.23)
  • Revision ID: robertc@robertcollins.net-20051002015346-587422189352289e
merge from upstream newformat

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 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
 
 
18
 
"""Proxy object for access to remote branches.
19
 
 
20
 
At the moment remote branches are only for HTTP and only for read
21
 
access.
22
 
"""
23
 
 
24
 
 
25
 
import gzip
26
 
from cStringIO import StringIO
27
 
import os
28
 
import urllib2
29
 
import urlparse
30
 
 
31
 
from bzrlib.errors import BzrError, BzrCheckError
32
 
from bzrlib.branch import Branch, LocalBranch, BZR_BRANCH_FORMAT_5
33
 
from bzrlib.trace import mutter
34
 
from bzrlib.weavestore import WeaveStore
35
 
from bzrlib.xml5 import serializer_v5
36
 
 
37
 
 
38
 
# velocitynet.com.au transparently proxies connections and thereby
39
 
# breaks keep-alive -- sucks!
40
 
 
41
 
 
42
 
ENABLE_URLGRABBER = False
43
 
 
44
 
from bzrlib.errors import BzrError, NoSuchRevision
45
 
 
46
 
class GetFailed(BzrError):
47
 
    def __init__(self, url, status):
48
 
        BzrError.__init__(self, "Get %s failed with status %s" % (url, status))
49
 
        self.url = url
50
 
        self.status = status
51
 
 
52
 
if ENABLE_URLGRABBER:
53
 
    import util.urlgrabber
54
 
    import util.urlgrabber.keepalive
55
 
    util.urlgrabber.keepalive.DEBUG = 0
56
 
    def get_url(path, compressed=False):
57
 
        try:
58
 
            url = path
59
 
            if compressed:
60
 
                url += '.gz'
61
 
            mutter("grab url %s" % url)
62
 
            url_f = util.urlgrabber.urlopen(url, keepalive=1, close_connection=0)
63
 
            if url_f.status != 200:
64
 
                raise GetFailed(url, url_f.status)
65
 
            if not compressed:
66
 
                return url_f
67
 
            else:
68
 
                return gzip.GzipFile(fileobj=StringIO(url_f.read()))
69
 
        except urllib2.URLError, e:
70
 
            raise BzrError("remote fetch failed: %r: %s" % (url, e))
71
 
else:
72
 
    def get_url(url, compressed=False):
73
 
        import urllib2
74
 
        if compressed:
75
 
            url += '.gz'
76
 
        mutter("get_url %s" % url)
77
 
        url_f = urllib2.urlopen(url)
78
 
        if compressed:
79
 
            return gzip.GzipFile(fileobj=StringIO(url_f.read()))
80
 
        else:
81
 
            return url_f
82
 
 
83
 
 
84
 
 
85
 
def _find_remote_root(url):
86
 
    """Return the prefix URL that corresponds to the branch root."""
87
 
    orig_url = url
88
 
    while True:
89
 
        try:
90
 
            fmt_url = url + '/.bzr/branch-format'
91
 
            ff = get_url(fmt_url)
92
 
            fmt = ff.read()
93
 
            ff.close()
94
 
 
95
 
            if fmt != BZR_BRANCH_FORMAT_5:
96
 
                raise BzrError("sorry, branch format %r not supported at url %s"
97
 
                               % (fmt, url))
98
 
            
99
 
            return url
100
 
        except urllib2.URLError:
101
 
            pass
102
 
 
103
 
        scheme, host, path = list(urlparse.urlparse(url))[:3]
104
 
        # discard params, query, fragment
105
 
        
106
 
        # strip off one component of the path component
107
 
        idx = path.rfind('/')
108
 
        if idx == -1 or path == '/':
109
 
            raise BzrError('no branch root found for URL %s'
110
 
                           ' or enclosing directories'
111
 
                           % orig_url)
112
 
        path = path[:idx]
113
 
        url = urlparse.urlunparse((scheme, host, path, '', '', ''))
114
 
        
115
 
 
116
 
 
117
 
class RemoteBranch(LocalBranch):
118
 
    def __init__(self, baseurl, find_root=True):
119
 
        """Create new proxy for a remote branch."""
120
 
        if find_root:
121
 
            self.base = _find_remote_root(baseurl)
122
 
        else:
123
 
            self.base = baseurl
124
 
        self._check_format(False)
125
 
        # is guaranteed to be a v5 store
126
 
 
127
 
        cfn = self.controlfilename
128
 
        assert self._branch_format == 5
129
 
        self.control_weaves = WeaveStore(cfn([]), get_url)
130
 
        self.weave_store = WeaveStore(cfn('weaves'), get_url)
131
 
        self.revision_store = RemoteStore(cfn('revision-store'))
132
 
 
133
 
    def __str__(self):
134
 
        b = getattr(self, 'baseurl', 'undefined')
135
 
        return '%s(%r)' % (self.__class__.__name__, b)
136
 
 
137
 
    __repr__ = __str__
138
 
 
139
 
    def setup_caching(self, cache_root):
140
 
        """Set up cached stores located under cache_root"""
141
 
        from bzrlib.meta_store import CachedStore
142
 
        for store_name in ('revision_store',):
143
 
            if not isinstance(getattr(self, store_name), CachedStore):
144
 
                cache_path = os.path.join(cache_root, store_name)
145
 
                os.mkdir(cache_path)
146
 
                new_store = CachedStore(getattr(self, store_name), cache_path)
147
 
                setattr(self, store_name, new_store)
148
 
 
149
 
    def controlfile(self, filename, mode):
150
 
        if mode not in ('rb', 'rt', 'r'):
151
 
            raise BzrError("file mode %r not supported for remote branches" % mode)
152
 
        return get_url(self.base + '/.bzr/' + filename, False)
153
 
 
154
 
 
155
 
    def lock_read(self):
156
 
        # no locking for remote branches yet
157
 
        pass
158
 
 
159
 
    def lock_write(self):
160
 
        from errors import LockError
161
 
        raise LockError("write lock not supported for remote branch %s"
162
 
                        % self.base)
163
 
 
164
 
    def unlock(self):
165
 
        pass
166
 
    
167
 
 
168
 
    def relpath(self, path):
169
 
        if not path.startswith(self.base):
170
 
            raise BzrError('path %r is not under base URL %r'
171
 
                           % (path, self.base))
172
 
        pl = len(self.base)
173
 
        return path[pl:].lstrip('/')
174
 
 
175
 
 
176
 
    def get_revision(self, revision_id):
177
 
        try:
178
 
            revf = self.revision_store[revision_id]
179
 
        except KeyError:
180
 
            raise NoSuchRevision(self, revision_id)
181
 
        r = serializer_v5.read_revision(revf)
182
 
        if r.revision_id != revision_id:
183
 
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
184
 
                                % (revision_id, r.revision_id))
185
 
        return r
186
 
 
187
 
 
188
 
class RemoteStore(object):
189
 
    def __init__(self, baseurl):
190
 
        self._baseurl = baseurl
191
 
        
192
 
 
193
 
    def _path(self, name):
194
 
        if '/' in name:
195
 
            raise ValueError('invalid store id', name)
196
 
        return self._baseurl + '/' + name
197
 
 
198
 
    def __contains__(self, fileid):
199
 
        try:
200
 
            self[fileid]
201
 
            return True
202
 
        except KeyError:
203
 
            return False
204
 
        
205
 
    def __getitem__(self, fileid):
206
 
        p = self._path(fileid)
207
 
        try:
208
 
            return get_url(p, compressed=True)
209
 
        except urllib2.URLError:
210
 
            pass
211
 
        try:
212
 
            return get_url(p, compressed=False)
213
 
        except urllib2.URLError:
214
 
            raise KeyError(fileid)
215
 
    
216
 
 
217