← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remotebranch.py

  • Committer: Martin Pool
  • Date: 2005-09-01 02:39:02 UTC
  • Revision ID: mbp@sourcefrog.net-20050901023902-2f1efa0ec064118a
- add note in old docs that they're out of date

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remotebranch.py
25
25
 
26
26
 
27
27
import gzip
28
 
from sets import Set
29
28
from cStringIO import StringIO
30
29
import urllib2
31
30
 
39
38
 
40
39
ENABLE_URLGRABBER = True
41
40
 
 
41
from bzrlib.errors import BzrError
 
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
42
48
 
43
49
if ENABLE_URLGRABBER:
44
 
    import urlgrabber
45
 
    import urlgrabber.keepalive
46
 
    urlgrabber.keepalive.DEBUG = 0
 
50
    import util.urlgrabber
 
51
    import util.urlgrabber.keepalive
 
52
    util.urlgrabber.keepalive.DEBUG = 0
47
53
    def get_url(path, compressed=False):
48
54
        try:
49
55
            url = path
50
56
            if compressed:
51
57
                url += '.gz'
52
58
            mutter("grab url %s" % url)
53
 
            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)
54
62
            if not compressed:
55
63
                return url_f
56
64
            else:
100
108
 
101
109
 
102
110
class RemoteBranch(Branch):
103
 
    def __init__(self, baseurl, find_root=True, lock_mode='r'):
 
111
    def __init__(self, baseurl, find_root=True):
104
112
        """Create new proxy for a remote branch."""
105
 
        if lock_mode not in ('', 'r'):
106
 
            raise BzrError('lock mode %r is not supported for remote branches'
107
 
                           % lock_mode)
108
 
 
109
113
        if find_root:
110
114
            self.baseurl = _find_remote_root(baseurl)
111
115
        else:
112
116
            self.baseurl = baseurl
113
117
            self._check_format()
114
118
 
 
119
        self.inventory_store = RemoteStore(baseurl + '/.bzr/inventory-store/')
 
120
        self.text_store = RemoteStore(baseurl + '/.bzr/text-store/')
 
121
        self.revision_store = RemoteStore(baseurl + '/.bzr/revision-store/')
 
122
 
115
123
    def __str__(self):
116
 
        return '%s(%r)' % (self.__class__.__name__, self.baseurl)
 
124
        b = getattr(self, 'baseurl', 'undefined')
 
125
        return '%s(%r)' % (self.__class__.__name__, b)
117
126
 
118
127
    __repr__ = __str__
119
128
 
122
131
            raise BzrError("file mode %r not supported for remote branches" % mode)
123
132
        return get_url(self.baseurl + '/.bzr/' + filename, False)
124
133
 
125
 
    def _need_readlock(self):
126
 
        # remote branch always safe for read
127
 
        pass
128
 
 
129
 
    def _need_writelock(self):
130
 
        raise BzrError("cannot get write lock on HTTP remote branch")
 
134
 
 
135
    def lock_read(self):
 
136
        # no locking for remote branches yet
 
137
        pass
 
138
 
 
139
    def lock_write(self):
 
140
        from errors import LockError
 
141
        raise LockError("write lock not supported for remote branch %s"
 
142
                        % self.baseurl)
 
143
 
 
144
    def unlock(self):
 
145
        pass
 
146
    
131
147
 
132
148
    def relpath(self, path):
133
149
        if not path.startswith(self.baseurl):
136
152
        pl = len(self.baseurl)
137
153
        return path[pl:].lstrip('/')
138
154
 
 
155
 
139
156
    def get_revision(self, revision_id):
140
 
        from revision import Revision
141
 
        revf = get_url(self.baseurl + '/.bzr/revision-store/' + revision_id,
142
 
                       True)
143
 
        r = Revision.read_xml(revf)
 
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)
144
161
        if r.revision_id != revision_id:
145
162
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
146
163
                                % (revision_id, r.revision_id))
147
164
        return r
 
165
 
 
166
 
 
167
class RemoteStore(object):
 
168
    def __init__(self, baseurl):
 
169
        self._baseurl = baseurl
 
170
        
 
171
 
 
172
    def _path(self, name):
 
173
        if '/' in name:
 
174
            raise ValueError('invalid store id', name)
 
175
        return self._baseurl + '/' + name
 
176
        
 
177
    def __getitem__(self, fileid):
 
178
        p = self._path(fileid)
 
179
        try:
 
180
            return get_url(p, compressed=True)
 
181
        except:
 
182
            raise KeyError(fileid)
148
183
    
149
184
 
150
 
def simple_walk():
151
 
    from revision import Revision
152
 
    from branch import Branch
153
 
    from inventory import Inventory
154
 
 
155
 
    got_invs = Set()
156
 
    got_texts = Set()
157
 
 
158
 
    print 'read history'
159
 
    history = get_url('/.bzr/revision-history').readlines()
160
 
    num_revs = len(history)
161
 
    for i, rev_id in enumerate(history):
162
 
        rev_id = rev_id.rstrip()
163
 
        print 'read revision %d/%d' % (i, num_revs)
164
 
 
165
 
        # python gzip needs a seekable file (!!) but the HTTP response
166
 
        # isn't, so we need to buffer it
167
 
 
168
 
        rev_f = get_url('/.bzr/revision-store/%s' % rev_id,
169
 
                        compressed=True)
170
 
 
171
 
        rev = Revision.read_xml(rev_f)
172
 
        print rev.message
173
 
        inv_id = rev.inventory_id
174
 
        if inv_id not in got_invs:
175
 
            print 'get inventory %s' % inv_id
176
 
            inv_f = get_url('/.bzr/inventory-store/%s' % inv_id,
177
 
                            compressed=True)
178
 
            inv = Inventory.read_xml(inv_f)
179
 
            print '%4d inventory entries' % len(inv)
180
 
 
181
 
            for path, ie in inv.iter_entries():
182
 
                text_id = ie.text_id
183
 
                if text_id == None:
184
 
                    continue
185
 
                if text_id in got_texts:
186
 
                    continue
187
 
                print '  fetch %s text {%s}' % (path, text_id)
188
 
                text_f = get_url('/.bzr/text-store/%s' % text_id,
189
 
                                 compressed=True)
190
 
                got_texts.add(text_id)
191
 
 
192
 
            got_invs.add(inv_id)
193
 
 
194
 
        print '----'
195
 
 
196
 
 
197
 
def try_me():
198
 
    BASE_URL = 'http://bazaar-ng.org/bzr/bzr.dev/'
199
 
    b = RemoteBranch(BASE_URL)
200
 
    ## print '\n'.join(b.revision_history())
201
 
    from log import show_log
202
 
    show_log(b)
203
 
 
204
 
 
205
 
if __name__ == '__main__':
206
 
    try_me()
207
185