← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remotebranch.py

bugfix from Aaron Bentley - bzrlib.graph.max_distance had an off-by-1 error

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remotebranch.py
1
 
#! /usr/bin/env python
2
 
 
3
1
# Copyright (C) 2005 Canonical Ltd
4
2
 
5
3
# This program is free software; you can redistribute it and/or modify
26
24
 
27
25
import gzip
28
26
from cStringIO import StringIO
 
27
import os
29
28
import urllib2
30
 
 
31
 
from errors import BzrError, BzrCheckError
32
 
from branch import Branch, BZR_BRANCH_FORMAT
33
 
from trace import mutter
34
 
 
35
 
# velocitynet.com.au transparently proxies connections and thereby
36
 
# breaks keep-alive -- sucks!
37
 
 
38
 
 
39
 
ENABLE_URLGRABBER = True
40
 
 
41
 
from bzrlib.errors import BzrError
 
29
import urlparse
 
30
 
 
31
from bzrlib.errors import BzrError, BzrCheckError
 
32
from bzrlib.branch import Branch, LocalBranch, BZR_BRANCH_FORMAT
 
33
from bzrlib.trace import mutter
 
34
from bzrlib.xml import serializer_v4
 
35
 
 
36
 
 
37
ENABLE_URLGRABBER = False
 
38
 
 
39
from bzrlib.errors import BzrError, NoSuchRevision
42
40
 
43
41
class GetFailed(BzrError):
44
42
    def __init__(self, url, status):
84
82
    orig_url = url
85
83
    while True:
86
84
        try:
87
 
            ff = get_url(url + '/.bzr/branch-format')
88
 
 
 
85
            fmt_url = url + '/.bzr/branch-format'
 
86
            ff = get_url(fmt_url)
89
87
            fmt = ff.read()
90
88
            ff.close()
91
89
 
98
96
        except urllib2.URLError:
99
97
            pass
100
98
 
101
 
        try:
102
 
            idx = url.rindex('/')
103
 
        except ValueError:
104
 
            raise BzrError('no branch root found for URL %s' % orig_url)
105
 
 
106
 
        url = url[:idx]        
107
 
        
108
 
 
109
 
 
110
 
class RemoteBranch(Branch):
 
99
        scheme, host, path = list(urlparse.urlparse(url))[:3]
 
100
        # discard params, query, fragment
 
101
        
 
102
        # strip off one component of the path component
 
103
        idx = path.rfind('/')
 
104
        if idx == -1 or path == '/':
 
105
            raise BzrError('no branch root found for URL %s'
 
106
                           ' or enclosing directories'
 
107
                           % orig_url)
 
108
        path = path[:idx]
 
109
        url = urlparse.urlunparse((scheme, host, path, '', '', ''))
 
110
        
 
111
 
 
112
 
 
113
class RemoteBranch(LocalBranch):
111
114
    def __init__(self, baseurl, find_root=True):
112
115
        """Create new proxy for a remote branch."""
113
116
        if find_root:
114
 
            self.baseurl = _find_remote_root(baseurl)
 
117
            self.base = _find_remote_root(baseurl)
115
118
        else:
116
 
            self.baseurl = baseurl
 
119
            self.base = baseurl
117
120
            self._check_format()
118
121
 
119
122
        self.inventory_store = RemoteStore(baseurl + '/.bzr/inventory-store/')
126
129
 
127
130
    __repr__ = __str__
128
131
 
 
132
    def setup_caching(self, cache_root):
 
133
        """Set up cached stores located under cache_root"""
 
134
        from bzrlib.meta_store import CachedStore
 
135
        for store_name in ('inventory_store', 'text_store', 'revision_store'):
 
136
            if not isinstance(getattr(self, store_name), CachedStore):
 
137
                cache_path = os.path.join(cache_root, store_name)
 
138
                os.mkdir(cache_path)
 
139
                new_store = CachedStore(getattr(self, store_name), cache_path)
 
140
                setattr(self, store_name, new_store)
 
141
 
129
142
    def controlfile(self, filename, mode):
130
143
        if mode not in ('rb', 'rt', 'r'):
131
144
            raise BzrError("file mode %r not supported for remote branches" % mode)
132
 
        return get_url(self.baseurl + '/.bzr/' + filename, False)
 
145
        return get_url(self.base + '/.bzr/' + filename, False)
133
146
 
134
147
 
135
148
    def lock_read(self):
139
152
    def lock_write(self):
140
153
        from errors import LockError
141
154
        raise LockError("write lock not supported for remote branch %s"
142
 
                        % self.baseurl)
 
155
                        % self.base)
143
156
 
144
157
    def unlock(self):
145
158
        pass
146
159
    
147
160
 
148
161
    def relpath(self, path):
149
 
        if not path.startswith(self.baseurl):
 
162
        if not path.startswith(self.base):
150
163
            raise BzrError('path %r is not under base URL %r'
151
 
                           % (path, self.baseurl))
152
 
        pl = len(self.baseurl)
 
164
                           % (path, self.base))
 
165
        pl = len(self.base)
153
166
        return path[pl:].lstrip('/')
154
167
 
155
168
 
156
169
    def get_revision(self, revision_id):
157
 
        from bzrlib.revision import Revision
158
 
        from bzrlib.xml import unpack_xml
159
 
        revf = self.revision_store[revision_id]
160
 
        r = unpack_xml(Revision, revf)
 
170
        try:
 
171
            revf = self.revision_store[revision_id]
 
172
        except KeyError:
 
173
            raise NoSuchRevision(self, revision_id)
 
174
        r = serializer_v4.read_revision(revf)
161
175
        if r.revision_id != revision_id:
162
176
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
163
177
                                % (revision_id, r.revision_id))
178
192
        p = self._path(fileid)
179
193
        try:
180
194
            return get_url(p, compressed=True)
181
 
        except:
 
195
        except urllib2.URLError:
 
196
            pass
 
197
        try:
 
198
            return get_url(p, compressed=False)
 
199
        except urllib2.URLError:
182
200
            raise KeyError(fileid)
183
201
    
184
202