← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remotebranch.py

  • Committer: Lalo Martins
  • Date: 2005-09-14 05:22:13 UTC
  • mfrom: (1185.1.10)
  • mto: (1185.1.22)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: lalo@exoweb.net-20050914052213-2aa5c1005959abdf
merging from Robert's integration branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remotebranch.py
26
26
 
27
27
import gzip
28
28
from cStringIO import StringIO
 
29
import os
29
30
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
 
31
import urlparse
 
32
 
 
33
from bzrlib.errors import BzrError, BzrCheckError
 
34
from bzrlib.branch import Branch, BZR_BRANCH_FORMAT
 
35
from bzrlib.trace import mutter
 
36
from bzrlib.xml import serializer_v4
 
37
 
 
38
 
 
39
ENABLE_URLGRABBER = False
 
40
 
 
41
from bzrlib.errors import BzrError, NoSuchRevision
42
42
 
43
43
class GetFailed(BzrError):
44
44
    def __init__(self, url, status):
47
47
        self.status = status
48
48
 
49
49
if ENABLE_URLGRABBER:
50
 
    import urlgrabber
51
 
    import urlgrabber.keepalive
52
 
    urlgrabber.keepalive.DEBUG = 0
 
50
    import util.urlgrabber
 
51
    import util.urlgrabber.keepalive
 
52
    util.urlgrabber.keepalive.DEBUG = 0
53
53
    def get_url(path, compressed=False):
54
54
        try:
55
55
            url = path
56
56
            if compressed:
57
57
                url += '.gz'
58
58
            mutter("grab url %s" % url)
59
 
            url_f = urlgrabber.urlopen(url, keepalive=1, close_connection=0)
 
59
            url_f = util.urlgrabber.urlopen(url, keepalive=1, close_connection=0)
60
60
            if url_f.status != 200:
61
61
                raise GetFailed(url, url_f.status)
62
62
            if not compressed:
84
84
    orig_url = url
85
85
    while True:
86
86
        try:
87
 
            ff = get_url(url + '/.bzr/branch-format')
88
 
 
 
87
            fmt_url = url + '/.bzr/branch-format'
 
88
            ff = get_url(fmt_url)
89
89
            fmt = ff.read()
90
90
            ff.close()
91
91
 
98
98
        except urllib2.URLError:
99
99
            pass
100
100
 
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]        
 
101
        scheme, host, path = list(urlparse.urlparse(url))[:3]
 
102
        # discard params, query, fragment
 
103
        
 
104
        # strip off one component of the path component
 
105
        idx = path.rfind('/')
 
106
        if idx == -1 or path == '/':
 
107
            raise BzrError('no branch root found for URL %s'
 
108
                           ' or enclosing directories'
 
109
                           % orig_url)
 
110
        path = path[:idx]
 
111
        url = urlparse.urlunparse((scheme, host, path, '', '', ''))
107
112
        
108
113
 
109
114
 
111
116
    def __init__(self, baseurl, find_root=True):
112
117
        """Create new proxy for a remote branch."""
113
118
        if find_root:
114
 
            self.baseurl = _find_remote_root(baseurl)
 
119
            self.base = _find_remote_root(baseurl)
115
120
        else:
116
 
            self.baseurl = baseurl
 
121
            self.base = baseurl
117
122
            self._check_format()
118
123
 
119
124
        self.inventory_store = RemoteStore(baseurl + '/.bzr/inventory-store/')
126
131
 
127
132
    __repr__ = __str__
128
133
 
 
134
    def setup_caching(self, cache_root):
 
135
        """Set up cached stores located under cache_root"""
 
136
        from bzrlib.meta_store import CachedStore
 
137
        for store_name in ('inventory_store', 'text_store', 'revision_store'):
 
138
            if not isinstance(getattr(self, store_name), CachedStore):
 
139
                cache_path = os.path.join(cache_root, store_name)
 
140
                os.mkdir(cache_path)
 
141
                new_store = CachedStore(getattr(self, store_name), cache_path)
 
142
                setattr(self, store_name, new_store)
 
143
 
129
144
    def controlfile(self, filename, mode):
130
145
        if mode not in ('rb', 'rt', 'r'):
131
146
            raise BzrError("file mode %r not supported for remote branches" % mode)
132
 
        return get_url(self.baseurl + '/.bzr/' + filename, False)
 
147
        return get_url(self.base + '/.bzr/' + filename, False)
133
148
 
134
149
 
135
150
    def lock_read(self):
139
154
    def lock_write(self):
140
155
        from errors import LockError
141
156
        raise LockError("write lock not supported for remote branch %s"
142
 
                        % self.baseurl)
 
157
                        % self.base)
143
158
 
144
159
    def unlock(self):
145
160
        pass
146
161
    
147
162
 
148
163
    def relpath(self, path):
149
 
        if not path.startswith(self.baseurl):
 
164
        if not path.startswith(self.base):
150
165
            raise BzrError('path %r is not under base URL %r'
151
 
                           % (path, self.baseurl))
152
 
        pl = len(self.baseurl)
 
166
                           % (path, self.base))
 
167
        pl = len(self.base)
153
168
        return path[pl:].lstrip('/')
154
169
 
155
170
 
156
171
    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)
 
172
        try:
 
173
            revf = self.revision_store[revision_id]
 
174
        except KeyError:
 
175
            raise NoSuchRevision(self, revision_id)
 
176
        r = serializer_v4.read_revision(revf)
161
177
        if r.revision_id != revision_id:
162
178
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
163
179
                                % (revision_id, r.revision_id))