← 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 07:50:07 UTC
  • Revision ID: mbp@sourcefrog.net-20050511075007-9ce9c01a6a5e6660
- fix header for listing of unknown files
- don't report root directory in status listing, since it's never 
  changed
- fix up status format in tests

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
 
31
 
from bzrlib.errors import BzrError, BzrCheckError
32
 
from bzrlib.branch import Branch, BZR_BRANCH_FORMAT_5
33
 
from bzrlib.trace import mutter
34
 
from bzrlib.xml5 import serializer_v5
 
32
from errors import BzrError, BzrCheckError
 
33
from branch import Branch, BZR_BRANCH_FORMAT
 
34
from trace import mutter
35
35
 
36
36
# velocitynet.com.au transparently proxies connections and thereby
37
37
# breaks keep-alive -- sucks!
38
38
 
39
39
 
40
 
ENABLE_URLGRABBER = False
41
 
 
42
 
from bzrlib.errors import BzrError, NoSuchRevision
43
 
 
44
 
class GetFailed(BzrError):
45
 
    def __init__(self, url, status):
46
 
        BzrError.__init__(self, "Get %s failed with status %s" % (url, status))
47
 
        self.url = url
48
 
        self.status = status
 
40
ENABLE_URLGRABBER = True
 
41
 
49
42
 
50
43
if ENABLE_URLGRABBER:
51
 
    import util.urlgrabber
52
 
    import util.urlgrabber.keepalive
53
 
    util.urlgrabber.keepalive.DEBUG = 0
 
44
    import urlgrabber
 
45
    import urlgrabber.keepalive
 
46
    urlgrabber.keepalive.DEBUG = 0
54
47
    def get_url(path, compressed=False):
55
48
        try:
56
49
            url = path
57
50
            if compressed:
58
51
                url += '.gz'
59
52
            mutter("grab url %s" % url)
60
 
            url_f = util.urlgrabber.urlopen(url, keepalive=1, close_connection=0)
61
 
            if url_f.status != 200:
62
 
                raise GetFailed(url, url_f.status)
 
53
            url_f = urlgrabber.urlopen(url, keepalive=1, close_connection=0)
63
54
            if not compressed:
64
55
                return url_f
65
56
            else:
90
81
            fmt = ff.read()
91
82
            ff.close()
92
83
 
93
 
            if fmt != BZR_BRANCH_FORMAT_5:
 
84
            fmt = fmt.rstrip('\r\n')
 
85
            if fmt != BZR_BRANCH_FORMAT.rstrip('\r\n'):
94
86
                raise BzrError("sorry, branch format %r not supported at url %s"
95
87
                               % (fmt, url))
96
88
            
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
 
        try:
159
 
            revf = self.revision_store[revision_id]
160
 
        except KeyError:
161
 
            raise NoSuchRevision(self, revision_id)
162
 
        r = serializer_v5.read_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)
163
144
        if r.revision_id != revision_id:
164
145
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
165
146
                                % (revision_id, r.revision_id))
166
147
        return r
167
 
 
168
 
 
169
 
class RemoteStore(object):
170
 
    def __init__(self, baseurl):
171
 
        self._baseurl = baseurl
172
 
        
173
 
 
174
 
    def _path(self, name):
175
 
        if '/' in name:
176
 
            raise ValueError('invalid store id', name)
177
 
        return self._baseurl + '/' + name
178
 
        
179
 
    def __getitem__(self, fileid):
180
 
        p = self._path(fileid)
181
 
        try:
182
 
            return get_url(p, compressed=True)
183
 
        except:
184
 
            raise KeyError(fileid)
185
148
    
186
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()
187
207