← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remotebranch.py

  • Committer: Aaron Bentley
  • Date: 2005-09-18 19:21:48 UTC
  • mto: (1185.1.29)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: aaron.bentley@utoronto.ca-20050918192148-3f9373ac85a83b02
Refactored and documented graph stuff

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
 
 
 
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
 
 
43
class GetFailed(BzrError):
 
44
    def __init__(self, url, status):
 
45
        BzrError.__init__(self, "Get %s failed with status %s" % (url, status))
 
46
        self.url = url
 
47
        self.status = status
41
48
 
42
49
if ENABLE_URLGRABBER:
43
 
    import urlgrabber
44
 
    import urlgrabber.keepalive
45
 
    urlgrabber.keepalive.DEBUG = 0
 
50
    import util.urlgrabber
 
51
    import util.urlgrabber.keepalive
 
52
    util.urlgrabber.keepalive.DEBUG = 0
46
53
    def get_url(path, compressed=False):
47
54
        try:
48
55
            url = path
49
56
            if compressed:
50
57
                url += '.gz'
51
58
            mutter("grab url %s" % url)
52
 
            url_f = urlgrabber.urlopen(url, keepalive=1, close_connection=0)
 
59
            url_f = util.urlgrabber.urlopen(url, keepalive=1, close_connection=0)
 
60
            if url_f.status != 200:
 
61
                raise GetFailed(url, url_f.status)
53
62
            if not compressed:
54
63
                return url_f
55
64
            else:
75
84
    orig_url = url
76
85
    while True:
77
86
        try:
78
 
            ff = get_url(url + '/.bzr/branch-format')
79
 
 
 
87
            fmt_url = url + '/.bzr/branch-format'
 
88
            ff = get_url(fmt_url)
80
89
            fmt = ff.read()
81
90
            ff.close()
82
91
 
89
98
        except urllib2.URLError:
90
99
            pass
91
100
 
92
 
        try:
93
 
            idx = url.rindex('/')
94
 
        except ValueError:
95
 
            raise BzrError('no branch root found for URL %s' % orig_url)
96
 
 
97
 
        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, '', '', ''))
98
112
        
99
113
 
100
114
 
101
115
class RemoteBranch(Branch):
102
 
    def __init__(self, baseurl, find_root=True, lock_mode='r'):
 
116
    def __init__(self, baseurl, find_root=True):
103
117
        """Create new proxy for a remote branch."""
104
 
        if lock_mode not in ('', 'r'):
105
 
            raise BzrError('lock mode %r is not supported for remote branches'
106
 
                           % lock_mode)
107
 
 
108
118
        if find_root:
109
119
            self.baseurl = _find_remote_root(baseurl)
110
120
        else:
113
123
 
114
124
        self.inventory_store = RemoteStore(baseurl + '/.bzr/inventory-store/')
115
125
        self.text_store = RemoteStore(baseurl + '/.bzr/text-store/')
 
126
        self.revision_store = RemoteStore(baseurl + '/.bzr/revision-store/')
116
127
 
117
128
    def __str__(self):
118
 
        return '%s(%r)' % (self.__class__.__name__, self.baseurl)
 
129
        b = getattr(self, 'baseurl', 'undefined')
 
130
        return '%s(%r)' % (self.__class__.__name__, b)
119
131
 
120
132
    __repr__ = __str__
121
133
 
124
136
            raise BzrError("file mode %r not supported for remote branches" % mode)
125
137
        return get_url(self.baseurl + '/.bzr/' + filename, False)
126
138
 
127
 
    def _need_readlock(self):
128
 
        # remote branch always safe for read
129
 
        pass
130
 
 
131
 
    def _need_writelock(self):
132
 
        raise BzrError("cannot get write lock on HTTP remote branch")
 
139
 
 
140
    def lock_read(self):
 
141
        # no locking for remote branches yet
 
142
        pass
 
143
 
 
144
    def lock_write(self):
 
145
        from errors import LockError
 
146
        raise LockError("write lock not supported for remote branch %s"
 
147
                        % self.baseurl)
 
148
 
 
149
    def unlock(self):
 
150
        pass
 
151
    
133
152
 
134
153
    def relpath(self, path):
135
154
        if not path.startswith(self.baseurl):
138
157
        pl = len(self.baseurl)
139
158
        return path[pl:].lstrip('/')
140
159
 
 
160
 
141
161
    def get_revision(self, revision_id):
142
 
        from revision import Revision
143
 
        revf = get_url(self.baseurl + '/.bzr/revision-store/' + revision_id,
144
 
                       True)
145
 
        r = Revision.read_xml(revf)
 
162
        try:
 
163
            revf = self.revision_store[revision_id]
 
164
        except KeyError:
 
165
            raise NoSuchRevision(self, revision_id)
 
166
        r = serializer_v4.read_revision(revf)
146
167
        if r.revision_id != revision_id:
147
168
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
148
169
                                % (revision_id, r.revision_id))
161
182
        
162
183
    def __getitem__(self, fileid):
163
184
        p = self._path(fileid)
164
 
        return get_url(p, compressed=True)
 
185
        try:
 
186
            return get_url(p, compressed=True)
 
187
        except urllib2.URLError:
 
188
            raise KeyError(fileid)
165
189
    
166
190
 
167
 
def simple_walk():
168
 
    """For experimental purposes, traverse many parts of a remote branch"""
169
 
    from revision import Revision
170
 
    from branch import Branch
171
 
    from inventory import Inventory
172
 
 
173
 
    got_invs = {}
174
 
    got_texts = {}
175
 
 
176
 
    print 'read history'
177
 
    history = get_url('/.bzr/revision-history').readlines()
178
 
    num_revs = len(history)
179
 
    for i, rev_id in enumerate(history):
180
 
        rev_id = rev_id.rstrip()
181
 
        print 'read revision %d/%d' % (i, num_revs)
182
 
 
183
 
        # python gzip needs a seekable file (!!) but the HTTP response
184
 
        # isn't, so we need to buffer it
185
 
 
186
 
        rev_f = get_url('/.bzr/revision-store/%s' % rev_id,
187
 
                        compressed=True)
188
 
 
189
 
        rev = Revision.read_xml(rev_f)
190
 
        print rev.message
191
 
        inv_id = rev.inventory_id
192
 
        if inv_id not in got_invs:
193
 
            print 'get inventory %s' % inv_id
194
 
            inv_f = get_url('/.bzr/inventory-store/%s' % inv_id,
195
 
                            compressed=True)
196
 
            inv = Inventory.read_xml(inv_f)
197
 
            print '%4d inventory entries' % len(inv)
198
 
 
199
 
            for path, ie in inv.iter_entries():
200
 
                text_id = ie.text_id
201
 
                if text_id == None:
202
 
                    continue
203
 
                if text_id in got_texts:
204
 
                    continue
205
 
                print '  fetch %s text {%s}' % (path, text_id)
206
 
                text_f = get_url('/.bzr/text-store/%s' % text_id,
207
 
                                 compressed=True)
208
 
                got_texts[text_id] = True
209
 
 
210
 
            got_invs.add[inv_id] = True
211
 
 
212
 
        print '----'
213
 
 
214
 
 
215
 
def try_me():
216
 
    BASE_URL = 'http://bazaar-ng.org/bzr/bzr.dev/'
217
 
    b = RemoteBranch(BASE_URL)
218
 
    ## print '\n'.join(b.revision_history())
219
 
    from log import show_log
220
 
    show_log(b)
221
 
 
222
 
 
223
 
if __name__ == '__main__':
224
 
    try_me()
225
191