← 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-09 06:09:42 UTC
  • Revision ID: mbp@sourcefrog.net-20050509060942-d9c9efd7feed0894
- more indicators at top of test output
- tidy up remotebranch stuff

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remotebranch.py
21
21
 
22
22
At the moment remote branches are only for HTTP and only for read
23
23
access.
 
24
 
24
25
"""
25
26
 
26
27
 
27
28
import gzip
 
29
from sets import Set
28
30
from cStringIO import StringIO
29
 
import urllib2
30
31
 
31
32
from errors import BzrError, BzrCheckError
32
 
from branch import Branch, BZR_BRANCH_FORMAT
33
 
from trace import mutter
 
33
from branch import Branch
34
34
 
35
35
# velocitynet.com.au transparently proxies connections and thereby
36
36
# breaks keep-alive -- sucks!
37
37
 
38
38
 
39
 
ENABLE_URLGRABBER = True
40
 
 
 
39
 
 
40
ENABLE_URLGRABBER = False
 
41
 
 
42
def get_url(url, compressed=False):
 
43
    import urllib2
 
44
    if compressed:
 
45
        url += '.gz'
 
46
    url_f = urllib2.urlopen(url)
 
47
    if compressed:
 
48
        return gzip.GzipFile(fileobj=StringIO(url_f.read()))
 
49
    else:
 
50
        return url_f
41
51
 
42
52
if ENABLE_URLGRABBER:
43
53
    import urlgrabber
48
58
            url = path
49
59
            if compressed:
50
60
                url += '.gz'
51
 
            mutter("grab url %s" % url)
52
61
            url_f = urlgrabber.urlopen(url, keepalive=1, close_connection=0)
53
62
            if not compressed:
54
63
                return url_f
56
65
                return gzip.GzipFile(fileobj=StringIO(url_f.read()))
57
66
        except urllib2.URLError, e:
58
67
            raise BzrError("remote fetch failed: %r: %s" % (url, e))
59
 
else:
60
 
    def get_url(url, compressed=False):
61
 
        import urllib2
62
 
        if compressed:
63
 
            url += '.gz'
64
 
        mutter("get_url %s" % url)
65
 
        url_f = urllib2.urlopen(url)
66
 
        if compressed:
67
 
            return gzip.GzipFile(fileobj=StringIO(url_f.read()))
68
 
        else:
69
 
            return url_f
70
 
 
71
 
 
72
 
 
73
 
def _find_remote_root(url):
74
 
    """Return the prefix URL that corresponds to the branch root."""
75
 
    orig_url = url
76
 
    while True:
77
 
        try:
78
 
            ff = get_url(url + '/.bzr/branch-format')
79
 
 
80
 
            fmt = ff.read()
81
 
            ff.close()
82
 
 
83
 
            fmt = fmt.rstrip('\r\n')
84
 
            if fmt != BZR_BRANCH_FORMAT.rstrip('\r\n'):
85
 
                raise BzrError("sorry, branch format %r not supported at url %s"
86
 
                               % (fmt, url))
87
 
            
88
 
            return url
89
 
        except urllib2.URLError:
90
 
            pass
91
 
 
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]        
98
 
        
99
68
 
100
69
 
101
70
class RemoteBranch(Branch):
102
 
    def __init__(self, baseurl, find_root=True):
 
71
    def __init__(self, baseurl):
103
72
        """Create new proxy for a remote branch."""
104
 
        if find_root:
105
 
            self.baseurl = _find_remote_root(baseurl)
106
 
        else:
107
 
            self.baseurl = baseurl
108
 
            self._check_format()
109
 
 
110
 
        self.inventory_store = RemoteStore(baseurl + '/.bzr/inventory-store/')
111
 
        self.text_store = RemoteStore(baseurl + '/.bzr/text-store/')
112
 
 
113
 
    def __str__(self):
114
 
        b = getattr(self, 'baseurl', 'undefined')
115
 
        return '%s(%r)' % (self.__class__.__name__, b)
116
 
 
117
 
    __repr__ = __str__
 
73
        self.baseurl = baseurl
 
74
        self._check_format()
118
75
 
119
76
    def controlfile(self, filename, mode):
120
77
        if mode not in ('rb', 'rt', 'r'):
121
78
            raise BzrError("file mode %r not supported for remote branches" % mode)
122
79
        return get_url(self.baseurl + '/.bzr/' + filename, False)
123
80
 
124
 
 
125
 
    def lock(self, mode):
126
 
        if mode != 'r':
127
 
            raise BzrError('lock mode %r not supported for remote branch %r' % (mode, self))
128
 
 
129
 
    def unlock(self):
 
81
    def _need_readlock(self):
 
82
        # remote branch always safe for read
130
83
        pass
131
 
    
132
84
 
133
 
    def relpath(self, path):
134
 
        if not path.startswith(self.baseurl):
135
 
            raise BzrError('path %r is not under base URL %r'
136
 
                           % (path, self.baseurl))
137
 
        pl = len(self.baseurl)
138
 
        return path[pl:].lstrip('/')
 
85
    def _need_writelock(self):
 
86
        raise BzrError("cannot get write lock on HTTP remote branch")
139
87
 
140
88
    def get_revision(self, revision_id):
141
89
        from revision import Revision
146
94
            raise BzrCheckError('revision stored as {%s} actually contains {%s}'
147
95
                                % (revision_id, r.revision_id))
148
96
        return r
149
 
 
150
 
 
151
 
class RemoteStore(object):
152
 
    def __init__(self, baseurl):
153
 
        self._baseurl = baseurl
154
 
        
155
 
 
156
 
    def _path(self, name):
157
 
        if '/' in name:
158
 
            raise ValueError('invalid store id', name)
159
 
        return self._baseurl + '/' + name
160
 
        
161
 
    def __getitem__(self, fileid):
162
 
        p = self._path(fileid)
163
 
        return get_url(p, compressed=True)
164
97
    
165
98
 
166
99
def simple_walk():
167
 
    """For experimental purposes, traverse many parts of a remote branch"""
168
100
    from revision import Revision
169
101
    from branch import Branch
170
102
    from inventory import Inventory
171
103
 
172
 
    got_invs = {}
173
 
    got_texts = {}
 
104
    got_invs = Set()
 
105
    got_texts = Set()
174
106
 
175
107
    print 'read history'
176
108
    history = get_url('/.bzr/revision-history').readlines()
204
136
                print '  fetch %s text {%s}' % (path, text_id)
205
137
                text_f = get_url('/.bzr/text-store/%s' % text_id,
206
138
                                 compressed=True)
207
 
                got_texts[text_id] = True
 
139
                got_texts.add(text_id)
208
140
 
209
 
            got_invs.add[inv_id] = True
 
141
            got_invs.add(inv_id)
210
142
 
211
143
        print '----'
212
144