← 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-05-11 06:12:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050511061244-b0eed343857f10d3
- remove dead code for cmd_compare_trees
- compare_trees new parameter want_unchanged to avoid allocating
  strings if not needed

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
28
29
from cStringIO import StringIO
29
30
import urllib2
30
31
 
38
39
 
39
40
ENABLE_URLGRABBER = True
40
41
 
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
48
42
 
49
43
if ENABLE_URLGRABBER:
50
 
    import util.urlgrabber
51
 
    import util.urlgrabber.keepalive
52
 
    util.urlgrabber.keepalive.DEBUG = 0
 
44
    import urlgrabber
 
45
    import urlgrabber.keepalive
 
46
    urlgrabber.keepalive.DEBUG = 0
53
47
    def get_url(path, compressed=False):
54
48
        try:
55
49
            url = path
56
50
            if compressed:
57
51
                url += '.gz'
58
52
            mutter("grab url %s" % url)
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
            url_f = urlgrabber.urlopen(url, keepalive=1, close_connection=0)
62
54
            if not compressed:
63
55
                return url_f
64
56
            else:
108
100
 
109
101
 
110
102
class RemoteBranch(Branch):
111
 
    def __init__(self, baseurl, find_root=True):
 
103
    def __init__(self, baseurl, find_root=True, lock_mode='r'):
112
104
        """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
 
113
109
        if find_root:
114
110
            self.baseurl = _find_remote_root(baseurl)
115
111
        else:
116
112
            self.baseurl = baseurl
117
113
            self._check_format()
118
114
 
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
 
 
123
115
    def __str__(self):
124
 
        b = getattr(self, 'baseurl', 'undefined')
125
 
        return '%s(%r)' % (self.__class__.__name__, b)
 
116
        return '%s(%r)' % (self.__class__.__name__, self.baseurl)
126
117
 
127
118
    __repr__ = __str__
128
119
 
131
122
            raise BzrError("file mode %r not supported for remote branches" % mode)
132
123
        return get_url(self.baseurl + '/.bzr/' + filename, False)
133
124
 
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
 
    
 
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")
147
131
 
148
132
    def relpath(self, path):
149
133
        if not path.startswith(self.baseurl):
152
136
        pl = len(self.baseurl)
153
137
        return path[pl:].lstrip('/')
154
138
 
155
 
 
156
139
    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)
 
140
        from revision import Revision
 
141
        revf = get_url(self.baseurl + '/.bzr/revision-store/' + revision_id,
 
142
                       True)
 
143
        r = Revision.read_xml(revf)
161
144
        if r.revision_id != revision_id:
162
145
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
163
146
                                % (revision_id, r.revision_id))
164
147
        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)
183
148
    
184
149
 
 
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()
185
207