/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

All check/reconcile tests passing now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
# TODO: At some point, handle upgrades by just passing the whole request
 
18
# across to run on the server.
 
19
 
 
20
from cStringIO import StringIO
 
21
 
 
22
from bzrlib import (
 
23
    branch,
 
24
    errors,
 
25
    lockdir,
 
26
    repository,
 
27
)
 
28
from bzrlib.branch import Branch, BranchReferenceFormat
 
29
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
30
from bzrlib.config import BranchConfig, TreeConfig
 
31
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
32
from bzrlib.errors import NoSuchRevision
 
33
from bzrlib.lockable_files import LockableFiles
 
34
from bzrlib.pack import ContainerReader
 
35
from bzrlib.revision import NULL_REVISION
 
36
from bzrlib.smart import client, vfs
 
37
from bzrlib.symbol_versioning import (
 
38
    deprecated_method,
 
39
    zero_ninetyone,
 
40
    )
 
41
from bzrlib.trace import note
 
42
 
 
43
# Note: RemoteBzrDirFormat is in bzrdir.py
 
44
 
 
45
class RemoteBzrDir(BzrDir):
 
46
    """Control directory on a remote server, accessed via bzr:// or similar."""
 
47
 
 
48
    def __init__(self, transport, _client=None):
 
49
        """Construct a RemoteBzrDir.
 
50
 
 
51
        :param _client: Private parameter for testing. Disables probing and the
 
52
            use of a real bzrdir.
 
53
        """
 
54
        BzrDir.__init__(self, transport, RemoteBzrDirFormat())
 
55
        # this object holds a delegated bzrdir that uses file-level operations
 
56
        # to talk to the other side
 
57
        self._real_bzrdir = None
 
58
 
 
59
        if _client is None:
 
60
            self._shared_medium = transport.get_shared_medium()
 
61
            self._client = client._SmartClient(self._shared_medium)
 
62
        else:
 
63
            self._client = _client
 
64
            self._shared_medium = None
 
65
            return
 
66
 
 
67
        path = self._path_for_remote_call(self._client)
 
68
        response = self._client.call('BzrDir.open', path)
 
69
        if response not in [('yes',), ('no',)]:
 
70
            raise errors.UnexpectedSmartServerResponse(response)
 
71
        if response == ('no',):
 
72
            raise errors.NotBranchError(path=transport.base)
 
73
 
 
74
    def _ensure_real(self):
 
75
        """Ensure that there is a _real_bzrdir set.
 
76
 
 
77
        Used before calls to self._real_bzrdir.
 
78
        """
 
79
        if not self._real_bzrdir:
 
80
            self._real_bzrdir = BzrDir.open_from_transport(
 
81
                self.root_transport, _server_formats=False)
 
82
 
 
83
    def create_repository(self, shared=False):
 
84
        self._ensure_real()
 
85
        self._real_bzrdir.create_repository(shared=shared)
 
86
        return self.open_repository()
 
87
 
 
88
    def create_branch(self):
 
89
        self._ensure_real()
 
90
        real_branch = self._real_bzrdir.create_branch()
 
91
        return RemoteBranch(self, self.find_repository(), real_branch)
 
92
 
 
93
    def destroy_branch(self):
 
94
        """See BzrDir.destroy_branch"""
 
95
        self._ensure_real()
 
96
        self._real_bzrdir.destroy_branch()
 
97
 
 
98
    def create_workingtree(self, revision_id=None):
 
99
        raise errors.NotLocalUrl(self.transport.base)
 
100
 
 
101
    def find_branch_format(self):
 
102
        """Find the branch 'format' for this bzrdir.
 
103
 
 
104
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
105
        """
 
106
        b = self.open_branch()
 
107
        return b._format
 
108
 
 
109
    def get_branch_reference(self):
 
110
        """See BzrDir.get_branch_reference()."""
 
111
        path = self._path_for_remote_call(self._client)
 
112
        response = self._client.call('BzrDir.open_branch', path)
 
113
        if response[0] == 'ok':
 
114
            if response[1] == '':
 
115
                # branch at this location.
 
116
                return None
 
117
            else:
 
118
                # a branch reference, use the existing BranchReference logic.
 
119
                return response[1]
 
120
        elif response == ('nobranch',):
 
121
            raise errors.NotBranchError(path=self.root_transport.base)
 
122
        else:
 
123
            raise errors.UnexpectedSmartServerResponse(response)
 
124
 
 
125
    def open_branch(self, _unsupported=False):
 
126
        assert _unsupported == False, 'unsupported flag support not implemented yet.'
 
127
        reference_url = self.get_branch_reference()
 
128
        if reference_url is None:
 
129
            # branch at this location.
 
130
            return RemoteBranch(self, self.find_repository())
 
131
        else:
 
132
            # a branch reference, use the existing BranchReference logic.
 
133
            format = BranchReferenceFormat()
 
134
            return format.open(self, _found=True, location=reference_url)
 
135
                
 
136
    def open_repository(self):
 
137
        path = self._path_for_remote_call(self._client)
 
138
        response = self._client.call('BzrDir.find_repository', path)
 
139
        assert response[0] in ('ok', 'norepository'), \
 
140
            'unexpected response code %s' % (response,)
 
141
        if response[0] == 'norepository':
 
142
            raise errors.NoRepositoryPresent(self)
 
143
        assert len(response) == 4, 'incorrect response length %s' % (response,)
 
144
        if response[1] == '':
 
145
            format = RemoteRepositoryFormat()
 
146
            format.rich_root_data = (response[2] == 'yes')
 
147
            format.supports_tree_reference = (response[3] == 'yes')
 
148
            return RemoteRepository(self, format)
 
149
        else:
 
150
            raise errors.NoRepositoryPresent(self)
 
151
 
 
152
    def open_workingtree(self, recommend_upgrade=True):
 
153
        self._ensure_real()
 
154
        if self._real_bzrdir.has_workingtree():
 
155
            raise errors.NotLocalUrl(self.root_transport)
 
156
        else:
 
157
            raise errors.NoWorkingTree(self.root_transport.base)
 
158
 
 
159
    def _path_for_remote_call(self, client):
 
160
        """Return the path to be used for this bzrdir in a remote call."""
 
161
        return client.remote_path_from_transport(self.root_transport)
 
162
 
 
163
    def get_branch_transport(self, branch_format):
 
164
        self._ensure_real()
 
165
        return self._real_bzrdir.get_branch_transport(branch_format)
 
166
 
 
167
    def get_repository_transport(self, repository_format):
 
168
        self._ensure_real()
 
169
        return self._real_bzrdir.get_repository_transport(repository_format)
 
170
 
 
171
    def get_workingtree_transport(self, workingtree_format):
 
172
        self._ensure_real()
 
173
        return self._real_bzrdir.get_workingtree_transport(workingtree_format)
 
174
 
 
175
    def can_convert_format(self):
 
176
        """Upgrading of remote bzrdirs is not supported yet."""
 
177
        return False
 
178
 
 
179
    def needs_format_conversion(self, format=None):
 
180
        """Upgrading of remote bzrdirs is not supported yet."""
 
181
        return False
 
182
 
 
183
    def clone(self, url, revision_id=None, force_new_repo=False):
 
184
        self._ensure_real()
 
185
        return self._real_bzrdir.clone(url, revision_id=revision_id,
 
186
            force_new_repo=force_new_repo)
 
187
 
 
188
 
 
189
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
190
    """Format for repositories accessed over a _SmartClient.
 
191
 
 
192
    Instances of this repository are represented by RemoteRepository
 
193
    instances.
 
194
 
 
195
    The RemoteRepositoryFormat is parameterised during construction
 
196
    to reflect the capabilities of the real, remote format. Specifically
 
197
    the attributes rich_root_data and supports_tree_reference are set
 
198
    on a per instance basis, and are not set (and should not be) at
 
199
    the class level.
 
200
    """
 
201
 
 
202
    _matchingbzrdir = RemoteBzrDirFormat
 
203
 
 
204
    def initialize(self, a_bzrdir, shared=False):
 
205
        assert isinstance(a_bzrdir, RemoteBzrDir), \
 
206
            '%r is not a RemoteBzrDir' % (a_bzrdir,)
 
207
        return a_bzrdir.create_repository(shared=shared)
 
208
    
 
209
    def open(self, a_bzrdir):
 
210
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
211
        return a_bzrdir.open_repository()
 
212
 
 
213
    def get_format_description(self):
 
214
        return 'bzr remote repository'
 
215
 
 
216
    def __eq__(self, other):
 
217
        return self.__class__ == other.__class__
 
218
 
 
219
    def check_conversion_target(self, target_format):
 
220
        if self.rich_root_data and not target_format.rich_root_data:
 
221
            raise errors.BadConversionTarget(
 
222
                'Does not support rich root data.', target_format)
 
223
        if (self.supports_tree_reference and
 
224
            not getattr(target_format, 'supports_tree_reference', False)):
 
225
            raise errors.BadConversionTarget(
 
226
                'Does not support nested trees', target_format)
 
227
 
 
228
 
 
229
class RemoteRepository(object):
 
230
    """Repository accessed over rpc.
 
231
 
 
232
    For the moment most operations are performed using local transport-backed
 
233
    Repository objects.
 
234
    """
 
235
 
 
236
    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
 
237
        """Create a RemoteRepository instance.
 
238
        
 
239
        :param remote_bzrdir: The bzrdir hosting this repository.
 
240
        :param format: The RemoteFormat object to use.
 
241
        :param real_repository: If not None, a local implementation of the
 
242
            repository logic for the repository, usually accessing the data
 
243
            via the VFS.
 
244
        :param _client: Private testing parameter - override the smart client
 
245
            to be used by the repository.
 
246
        """
 
247
        if real_repository:
 
248
            self._real_repository = real_repository
 
249
        else:
 
250
            self._real_repository = None
 
251
        self.bzrdir = remote_bzrdir
 
252
        if _client is None:
 
253
            self._client = client._SmartClient(self.bzrdir._shared_medium)
 
254
        else:
 
255
            self._client = _client
 
256
        self._format = format
 
257
        self._lock_mode = None
 
258
        self._lock_token = None
 
259
        self._lock_count = 0
 
260
        self._leave_lock = False
 
261
        # for tests
 
262
        # These depend on the actual remote format, so force it off for maximum
 
263
        # compatibility.
 
264
        self._reconcile_does_inventory_gc = False
 
265
        self._reconcile_fixes_text_parents = False
 
266
        self._reconcile_backsup_inventory = False
 
267
        self.base = self.bzrdir.transport.base
 
268
 
 
269
    def __str__(self):
 
270
        return "%s(%s)" % (self.__class__.__name__, self.base)
 
271
 
 
272
    __repr__ = __str__
 
273
 
 
274
    def abort_write_group(self):
 
275
        """Complete a write group on the decorated repository.
 
276
        
 
277
        Smart methods peform operations in a single step so this api
 
278
        is not really applicable except as a compatibility thunk
 
279
        for older plugins that don't use e.g. the CommitBuilder
 
280
        facility.
 
281
        """
 
282
        self._ensure_real()
 
283
        return self._real_repository.abort_write_group()
 
284
 
 
285
    def commit_write_group(self):
 
286
        """Complete a write group on the decorated repository.
 
287
        
 
288
        Smart methods peform operations in a single step so this api
 
289
        is not really applicable except as a compatibility thunk
 
290
        for older plugins that don't use e.g. the CommitBuilder
 
291
        facility.
 
292
        """
 
293
        self._ensure_real()
 
294
        return self._real_repository.commit_write_group()
 
295
 
 
296
    def _ensure_real(self):
 
297
        """Ensure that there is a _real_repository set.
 
298
 
 
299
        Used before calls to self._real_repository.
 
300
        """
 
301
        if not self._real_repository:
 
302
            self.bzrdir._ensure_real()
 
303
            #self._real_repository = self.bzrdir._real_bzrdir.open_repository()
 
304
            self._set_real_repository(self.bzrdir._real_bzrdir.open_repository())
 
305
 
 
306
    def get_revision_graph(self, revision_id=None):
 
307
        """See Repository.get_revision_graph()."""
 
308
        if revision_id is None:
 
309
            revision_id = ''
 
310
        elif revision_id == NULL_REVISION:
 
311
            return {}
 
312
 
 
313
        path = self.bzrdir._path_for_remote_call(self._client)
 
314
        assert type(revision_id) is str
 
315
        response = self._client.call_expecting_body(
 
316
            'Repository.get_revision_graph', path, revision_id)
 
317
        if response[0][0] not in ['ok', 'nosuchrevision']:
 
318
            raise errors.UnexpectedSmartServerResponse(response[0])
 
319
        if response[0][0] == 'ok':
 
320
            coded = response[1].read_body_bytes()
 
321
            if coded == '':
 
322
                # no revisions in this repository!
 
323
                return {}
 
324
            lines = coded.split('\n')
 
325
            revision_graph = {}
 
326
            for line in lines:
 
327
                d = tuple(line.split())
 
328
                revision_graph[d[0]] = d[1:]
 
329
                
 
330
            return revision_graph
 
331
        else:
 
332
            response_body = response[1].read_body_bytes()
 
333
            assert response_body == ''
 
334
            raise NoSuchRevision(self, revision_id)
 
335
 
 
336
    def has_revision(self, revision_id):
 
337
        """See Repository.has_revision()."""
 
338
        if revision_id is None:
 
339
            # The null revision is always present.
 
340
            return True
 
341
        path = self.bzrdir._path_for_remote_call(self._client)
 
342
        response = self._client.call('Repository.has_revision', path, revision_id)
 
343
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
 
344
        return response[0] == 'yes'
 
345
 
 
346
    def has_same_location(self, other):
 
347
        return (self.__class__ == other.__class__ and
 
348
                self.bzrdir.transport.base == other.bzrdir.transport.base)
 
349
        
 
350
    def get_graph(self, other_repository=None):
 
351
        """Return the graph for this repository format"""
 
352
        self._ensure_real()
 
353
        return self._real_repository.get_graph(other_repository)
 
354
 
 
355
    def gather_stats(self, revid=None, committers=None):
 
356
        """See Repository.gather_stats()."""
 
357
        path = self.bzrdir._path_for_remote_call(self._client)
 
358
        if revid in (None, NULL_REVISION):
 
359
            fmt_revid = ''
 
360
        else:
 
361
            fmt_revid = revid
 
362
        if committers is None or not committers:
 
363
            fmt_committers = 'no'
 
364
        else:
 
365
            fmt_committers = 'yes'
 
366
        response = self._client.call_expecting_body(
 
367
            'Repository.gather_stats', path, fmt_revid, fmt_committers)
 
368
        assert response[0][0] == 'ok', \
 
369
            'unexpected response code %s' % (response[0],)
 
370
 
 
371
        body = response[1].read_body_bytes()
 
372
        result = {}
 
373
        for line in body.split('\n'):
 
374
            if not line:
 
375
                continue
 
376
            key, val_text = line.split(':')
 
377
            if key in ('revisions', 'size', 'committers'):
 
378
                result[key] = int(val_text)
 
379
            elif key in ('firstrev', 'latestrev'):
 
380
                values = val_text.split(' ')[1:]
 
381
                result[key] = (float(values[0]), long(values[1]))
 
382
 
 
383
        return result
 
384
 
 
385
    def get_physical_lock_status(self):
 
386
        """See Repository.get_physical_lock_status()."""
 
387
        return False
 
388
 
 
389
    def is_in_write_group(self):
 
390
        """Return True if there is an open write group.
 
391
 
 
392
        write groups are only applicable locally for the smart server..
 
393
        """
 
394
        if self._real_repository:
 
395
            return self._real_repository.is_in_write_group()
 
396
 
 
397
    def is_locked(self):
 
398
        return self._lock_count >= 1
 
399
 
 
400
    def is_shared(self):
 
401
        """See Repository.is_shared()."""
 
402
        path = self.bzrdir._path_for_remote_call(self._client)
 
403
        response = self._client.call('Repository.is_shared', path)
 
404
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
 
405
        return response[0] == 'yes'
 
406
 
 
407
    def is_write_locked(self):
 
408
        return self._lock_mode == 'w'
 
409
 
 
410
    def lock_read(self):
 
411
        # wrong eventually - want a local lock cache context
 
412
        if not self._lock_mode:
 
413
            self._lock_mode = 'r'
 
414
            self._lock_count = 1
 
415
            if self._real_repository is not None:
 
416
                self._real_repository.lock_read()
 
417
        else:
 
418
            self._lock_count += 1
 
419
 
 
420
    def _remote_lock_write(self, token):
 
421
        path = self.bzrdir._path_for_remote_call(self._client)
 
422
        if token is None:
 
423
            token = ''
 
424
        response = self._client.call('Repository.lock_write', path, token)
 
425
        if response[0] == 'ok':
 
426
            ok, token = response
 
427
            return token
 
428
        elif response[0] == 'LockContention':
 
429
            raise errors.LockContention('(remote lock)')
 
430
        elif response[0] == 'UnlockableTransport':
 
431
            raise errors.UnlockableTransport(self.bzrdir.root_transport)
 
432
        elif response[0] == 'LockFailed':
 
433
            raise errors.LockFailed(response[1], response[2])
 
434
        else:
 
435
            raise errors.UnexpectedSmartServerResponse(response)
 
436
 
 
437
    def lock_write(self, token=None):
 
438
        if not self._lock_mode:
 
439
            self._lock_token = self._remote_lock_write(token)
 
440
            assert self._lock_token, 'Remote server did not return a token!'
 
441
            if self._real_repository is not None:
 
442
                self._real_repository.lock_write(token=self._lock_token)
 
443
            if token is not None:
 
444
                self._leave_lock = True
 
445
            else:
 
446
                self._leave_lock = False
 
447
            self._lock_mode = 'w'
 
448
            self._lock_count = 1
 
449
        elif self._lock_mode == 'r':
 
450
            raise errors.ReadOnlyError(self)
 
451
        else:
 
452
            self._lock_count += 1
 
453
        return self._lock_token
 
454
 
 
455
    def leave_lock_in_place(self):
 
456
        self._leave_lock = True
 
457
 
 
458
    def dont_leave_lock_in_place(self):
 
459
        self._leave_lock = False
 
460
 
 
461
    def _set_real_repository(self, repository):
 
462
        """Set the _real_repository for this repository.
 
463
 
 
464
        :param repository: The repository to fallback to for non-hpss
 
465
            implemented operations.
 
466
        """
 
467
        assert not isinstance(repository, RemoteRepository)
 
468
        self._real_repository = repository
 
469
        if self._lock_mode == 'w':
 
470
            # if we are already locked, the real repository must be able to
 
471
            # acquire the lock with our token.
 
472
            self._real_repository.lock_write(self._lock_token)
 
473
        elif self._lock_mode == 'r':
 
474
            self._real_repository.lock_read()
 
475
 
 
476
    def start_write_group(self):
 
477
        """Start a write group on the decorated repository.
 
478
        
 
479
        Smart methods peform operations in a single step so this api
 
480
        is not really applicable except as a compatibility thunk
 
481
        for older plugins that don't use e.g. the CommitBuilder
 
482
        facility.
 
483
        """
 
484
        self._ensure_real()
 
485
        return self._real_repository.start_write_group()
 
486
 
 
487
    def _unlock(self, token):
 
488
        path = self.bzrdir._path_for_remote_call(self._client)
 
489
        response = self._client.call('Repository.unlock', path, token)
 
490
        if response == ('ok',):
 
491
            return
 
492
        elif response[0] == 'TokenMismatch':
 
493
            raise errors.TokenMismatch(token, '(remote token)')
 
494
        else:
 
495
            raise errors.UnexpectedSmartServerResponse(response)
 
496
 
 
497
    def unlock(self):
 
498
        self._lock_count -= 1
 
499
        if self._lock_count > 0:
 
500
            return
 
501
        old_mode = self._lock_mode
 
502
        self._lock_mode = None
 
503
        try:
 
504
            # The real repository is responsible at present for raising an
 
505
            # exception if it's in an unfinished write group.  However, it
 
506
            # normally will *not* actually remove the lock from disk - that's
 
507
            # done by the server on receiving the Repository.unlock call.
 
508
            # This is just to let the _real_repository stay up to date.
 
509
            if self._real_repository is not None:
 
510
                self._real_repository.unlock()
 
511
        finally:
 
512
            # The rpc-level lock should be released even if there was a
 
513
            # problem releasing the vfs-based lock.
 
514
            if old_mode == 'w':
 
515
                # Only write-locked repositories need to make a remote method
 
516
                # call to perfom the unlock.
 
517
                assert self._lock_token, \
 
518
                    '%s is locked, but has no token' \
 
519
                    % self
 
520
                old_token = self._lock_token
 
521
                self._lock_token = None
 
522
                if not self._leave_lock:
 
523
                    self._unlock(old_token)
 
524
 
 
525
    def break_lock(self):
 
526
        # should hand off to the network
 
527
        self._ensure_real()
 
528
        return self._real_repository.break_lock()
 
529
 
 
530
    def _get_tarball(self, compression):
 
531
        """Return a TemporaryFile containing a repository tarball.
 
532
        
 
533
        Returns None if the server does not support sending tarballs.
 
534
        """
 
535
        import tempfile
 
536
        path = self.bzrdir._path_for_remote_call(self._client)
 
537
        response, protocol = self._client.call_expecting_body(
 
538
            'Repository.tarball', path, compression)
 
539
        if response[0] == 'ok':
 
540
            # Extract the tarball and return it
 
541
            t = tempfile.NamedTemporaryFile()
 
542
            # TODO: rpc layer should read directly into it...
 
543
            t.write(protocol.read_body_bytes())
 
544
            t.seek(0)
 
545
            return t
 
546
        if (response == ('error', "Generic bzr smart protocol error: "
 
547
                "bad request 'Repository.tarball'") or
 
548
              response == ('error', "Generic bzr smart protocol error: "
 
549
                "bad request u'Repository.tarball'")):
 
550
            protocol.cancel_read_body()
 
551
            return None
 
552
        raise errors.UnexpectedSmartServerResponse(response)
 
553
 
 
554
    def sprout(self, to_bzrdir, revision_id=None):
 
555
        # TODO: Option to control what format is created?
 
556
        dest_repo = to_bzrdir.create_repository()
 
557
        dest_repo.fetch(self, revision_id=revision_id)
 
558
        return dest_repo
 
559
 
 
560
    ### These methods are just thin shims to the VFS object for now.
 
561
 
 
562
    def revision_tree(self, revision_id):
 
563
        self._ensure_real()
 
564
        return self._real_repository.revision_tree(revision_id)
 
565
 
 
566
    def get_serializer_format(self):
 
567
        self._ensure_real()
 
568
        return self._real_repository.get_serializer_format()
 
569
 
 
570
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
571
                           timezone=None, committer=None, revprops=None,
 
572
                           revision_id=None):
 
573
        # FIXME: It ought to be possible to call this without immediately
 
574
        # triggering _ensure_real.  For now it's the easiest thing to do.
 
575
        self._ensure_real()
 
576
        builder = self._real_repository.get_commit_builder(branch, parents,
 
577
                config, timestamp=timestamp, timezone=timezone,
 
578
                committer=committer, revprops=revprops, revision_id=revision_id)
 
579
        # Make the builder use this RemoteRepository rather than the real one.
 
580
        builder.repository = self
 
581
        return builder
 
582
 
 
583
    @needs_write_lock
 
584
    def add_inventory(self, revid, inv, parents):
 
585
        self._ensure_real()
 
586
        return self._real_repository.add_inventory(revid, inv, parents)
 
587
 
 
588
    @needs_write_lock
 
589
    def add_revision(self, rev_id, rev, inv=None, config=None):
 
590
        self._ensure_real()
 
591
        return self._real_repository.add_revision(
 
592
            rev_id, rev, inv=inv, config=config)
 
593
 
 
594
    @needs_read_lock
 
595
    def get_inventory(self, revision_id):
 
596
        self._ensure_real()
 
597
        return self._real_repository.get_inventory(revision_id)
 
598
 
 
599
    @needs_read_lock
 
600
    def get_revision(self, revision_id):
 
601
        self._ensure_real()
 
602
        return self._real_repository.get_revision(revision_id)
 
603
 
 
604
    @property
 
605
    def weave_store(self):
 
606
        self._ensure_real()
 
607
        return self._real_repository.weave_store
 
608
 
 
609
    def get_transaction(self):
 
610
        self._ensure_real()
 
611
        return self._real_repository.get_transaction()
 
612
 
 
613
    @needs_read_lock
 
614
    def clone(self, a_bzrdir, revision_id=None):
 
615
        self._ensure_real()
 
616
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
617
 
 
618
    def make_working_trees(self):
 
619
        """RemoteRepositories never create working trees by default."""
 
620
        return False
 
621
 
 
622
    def fetch(self, source, revision_id=None, pb=None):
 
623
        if self.has_same_location(source):
 
624
            # check that last_revision is in 'from' and then return a
 
625
            # no-operation.
 
626
            if (revision_id is not None and
 
627
                not _mod_revision.is_null(revision_id)):
 
628
                self.get_revision(revision_id)
 
629
            return 0, []
 
630
        self._ensure_real()
 
631
        return self._real_repository.fetch(
 
632
            source, revision_id=revision_id, pb=pb)
 
633
 
 
634
    def create_bundle(self, target, base, fileobj, format=None):
 
635
        self._ensure_real()
 
636
        self._real_repository.create_bundle(target, base, fileobj, format)
 
637
 
 
638
    @property
 
639
    def control_weaves(self):
 
640
        self._ensure_real()
 
641
        return self._real_repository.control_weaves
 
642
 
 
643
    @needs_read_lock
 
644
    def get_ancestry(self, revision_id, topo_sorted=True):
 
645
        self._ensure_real()
 
646
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
 
647
 
 
648
    @needs_read_lock
 
649
    def get_inventory_weave(self):
 
650
        self._ensure_real()
 
651
        return self._real_repository.get_inventory_weave()
 
652
 
 
653
    def fileids_altered_by_revision_ids(self, revision_ids):
 
654
        self._ensure_real()
 
655
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
 
656
 
 
657
    def get_versioned_file_checker(self, revisions, revision_versions_cache):
 
658
        self._ensure_real()
 
659
        return self._real_repository.get_versioned_file_checker(
 
660
            revisions, revision_versions_cache)
 
661
        
 
662
    def iter_files_bytes(self, desired_files):
 
663
        """See Repository.iter_file_bytes.
 
664
        """
 
665
        self._ensure_real()
 
666
        return self._real_repository.iter_files_bytes(desired_files)
 
667
 
 
668
    @needs_read_lock
 
669
    def get_signature_text(self, revision_id):
 
670
        self._ensure_real()
 
671
        return self._real_repository.get_signature_text(revision_id)
 
672
 
 
673
    @needs_read_lock
 
674
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
675
        self._ensure_real()
 
676
        return self._real_repository.get_revision_graph_with_ghosts(
 
677
            revision_ids=revision_ids)
 
678
 
 
679
    @needs_read_lock
 
680
    def get_inventory_xml(self, revision_id):
 
681
        self._ensure_real()
 
682
        return self._real_repository.get_inventory_xml(revision_id)
 
683
 
 
684
    def deserialise_inventory(self, revision_id, xml):
 
685
        self._ensure_real()
 
686
        return self._real_repository.deserialise_inventory(revision_id, xml)
 
687
 
 
688
    def reconcile(self, other=None, thorough=False):
 
689
        self._ensure_real()
 
690
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
691
        
 
692
    def all_revision_ids(self):
 
693
        self._ensure_real()
 
694
        return self._real_repository.all_revision_ids()
 
695
    
 
696
    @needs_read_lock
 
697
    def get_deltas_for_revisions(self, revisions):
 
698
        self._ensure_real()
 
699
        return self._real_repository.get_deltas_for_revisions(revisions)
 
700
 
 
701
    @needs_read_lock
 
702
    def get_revision_delta(self, revision_id):
 
703
        self._ensure_real()
 
704
        return self._real_repository.get_revision_delta(revision_id)
 
705
 
 
706
    @needs_read_lock
 
707
    def revision_trees(self, revision_ids):
 
708
        self._ensure_real()
 
709
        return self._real_repository.revision_trees(revision_ids)
 
710
 
 
711
    @needs_read_lock
 
712
    def get_revision_reconcile(self, revision_id):
 
713
        self._ensure_real()
 
714
        return self._real_repository.get_revision_reconcile(revision_id)
 
715
 
 
716
    @needs_read_lock
 
717
    def check(self, revision_ids=None):
 
718
        self._ensure_real()
 
719
        return self._real_repository.check(revision_ids=revision_ids)
 
720
 
 
721
    def copy_content_into(self, destination, revision_id=None):
 
722
        self._ensure_real()
 
723
        return self._real_repository.copy_content_into(
 
724
            destination, revision_id=revision_id)
 
725
 
 
726
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
 
727
        # get a tarball of the remote repository, and copy from that into the
 
728
        # destination
 
729
        from bzrlib import osutils
 
730
        import tarfile
 
731
        import tempfile
 
732
        from StringIO import StringIO
 
733
        # TODO: Maybe a progress bar while streaming the tarball?
 
734
        note("Copying repository content as tarball...")
 
735
        tar_file = self._get_tarball('bz2')
 
736
        if tar_file is None:
 
737
            return None
 
738
        destination = to_bzrdir.create_repository()
 
739
        try:
 
740
            tar = tarfile.open('repository', fileobj=tar_file,
 
741
                mode='r|bz2')
 
742
            tmpdir = tempfile.mkdtemp()
 
743
            try:
 
744
                _extract_tar(tar, tmpdir)
 
745
                tmp_bzrdir = BzrDir.open(tmpdir)
 
746
                tmp_repo = tmp_bzrdir.open_repository()
 
747
                tmp_repo.copy_content_into(destination, revision_id)
 
748
            finally:
 
749
                osutils.rmtree(tmpdir)
 
750
        finally:
 
751
            tar_file.close()
 
752
        return destination
 
753
        # TODO: Suggestion from john: using external tar is much faster than
 
754
        # python's tarfile library, but it may not work on windows.
 
755
 
 
756
    @needs_write_lock
 
757
    def pack(self):
 
758
        """Compress the data within the repository.
 
759
 
 
760
        This is not currently implemented within the smart server.
 
761
        """
 
762
        self._ensure_real()
 
763
        return self._real_repository.pack()
 
764
 
 
765
    def set_make_working_trees(self, new_value):
 
766
        raise NotImplementedError(self.set_make_working_trees)
 
767
 
 
768
    @needs_write_lock
 
769
    def sign_revision(self, revision_id, gpg_strategy):
 
770
        self._ensure_real()
 
771
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
772
 
 
773
    @needs_read_lock
 
774
    def get_revisions(self, revision_ids):
 
775
        self._ensure_real()
 
776
        return self._real_repository.get_revisions(revision_ids)
 
777
 
 
778
    def supports_rich_root(self):
 
779
        self._ensure_real()
 
780
        return self._real_repository.supports_rich_root()
 
781
 
 
782
    def iter_reverse_revision_history(self, revision_id):
 
783
        self._ensure_real()
 
784
        return self._real_repository.iter_reverse_revision_history(revision_id)
 
785
 
 
786
    @property
 
787
    def _serializer(self):
 
788
        self._ensure_real()
 
789
        return self._real_repository._serializer
 
790
 
 
791
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
792
        self._ensure_real()
 
793
        return self._real_repository.store_revision_signature(
 
794
            gpg_strategy, plaintext, revision_id)
 
795
 
 
796
    def has_signature_for_revision_id(self, revision_id):
 
797
        self._ensure_real()
 
798
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
799
 
 
800
    def get_data_stream(self, revision_ids):
 
801
        path = self.bzrdir._path_for_remote_call(self._client)
 
802
        response, protocol = self._client.call_expecting_body(
 
803
            'Repository.stream_knit_data_for_revisions', path, *revision_ids)
 
804
        if response == ('ok',):
 
805
            return self._deserialise_stream(protocol)
 
806
        elif (response == ('error', "Generic bzr smart protocol error: "
 
807
                "bad request 'Repository.stream_knit_data_for_revisions'") or
 
808
              response == ('error', "Generic bzr smart protocol error: "
 
809
                "bad request u'Repository.stream_knit_data_for_revisions'")):
 
810
            protocol.cancel_read_body()
 
811
            self._ensure_real()
 
812
            return self._real_repository.get_data_stream(revision_ids)
 
813
        else:
 
814
            raise errors.UnexpectedSmartServerResponse(response)
 
815
 
 
816
    def _deserialise_stream(self, protocol):
 
817
        buffer = StringIO(protocol.read_body_bytes())
 
818
        reader = ContainerReader(buffer)
 
819
        for record_names, read_bytes in reader.iter_records():
 
820
            try:
 
821
                # These records should have only one name, and that name
 
822
                # should be a one-element tuple.
 
823
                [name_tuple] = record_names
 
824
            except ValueError:
 
825
                raise errors.SmartProtocolError(
 
826
                    'Repository data stream had invalid record name %r'
 
827
                    % (record_names,))
 
828
            yield name_tuple, read_bytes(None)
 
829
 
 
830
    def insert_data_stream(self, stream):
 
831
        self._ensure_real()
 
832
        self._real_repository.insert_data_stream(stream)
 
833
 
 
834
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
 
835
        self._ensure_real()
 
836
        return self._real_repository.item_keys_introduced_by(revision_ids,
 
837
            _files_pb=_files_pb)
 
838
 
 
839
    def revision_graph_can_have_wrong_parents(self):
 
840
        # The answer depends on the remote repo format.
 
841
        self._ensure_real()
 
842
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
843
 
 
844
    def _find_inconsistent_revision_parents(self):
 
845
        self._ensure_real()
 
846
        return self._real_repository._find_inconsistent_revision_parents()
 
847
 
 
848
    def _check_for_inconsistent_revision_parents(self):
 
849
        self._ensure_real()
 
850
        return self._real_repository._check_for_inconsistent_revision_parents()
 
851
 
 
852
 
 
853
class RemoteBranchLockableFiles(LockableFiles):
 
854
    """A 'LockableFiles' implementation that talks to a smart server.
 
855
    
 
856
    This is not a public interface class.
 
857
    """
 
858
 
 
859
    def __init__(self, bzrdir, _client):
 
860
        self.bzrdir = bzrdir
 
861
        self._client = _client
 
862
        self._need_find_modes = True
 
863
        LockableFiles.__init__(
 
864
            self, bzrdir.get_branch_transport(None),
 
865
            'lock', lockdir.LockDir)
 
866
 
 
867
    def _find_modes(self):
 
868
        # RemoteBranches don't let the client set the mode of control files.
 
869
        self._dir_mode = None
 
870
        self._file_mode = None
 
871
 
 
872
    def get(self, path):
 
873
        """'get' a remote path as per the LockableFiles interface.
 
874
 
 
875
        :param path: the file to 'get'. If this is 'branch.conf', we do not
 
876
             just retrieve a file, instead we ask the smart server to generate
 
877
             a configuration for us - which is retrieved as an INI file.
 
878
        """
 
879
        if path == 'branch.conf':
 
880
            path = self.bzrdir._path_for_remote_call(self._client)
 
881
            response = self._client.call_expecting_body(
 
882
                'Branch.get_config_file', path)
 
883
            assert response[0][0] == 'ok', \
 
884
                'unexpected response code %s' % (response[0],)
 
885
            return StringIO(response[1].read_body_bytes())
 
886
        else:
 
887
            # VFS fallback.
 
888
            return LockableFiles.get(self, path)
 
889
 
 
890
 
 
891
class RemoteBranchFormat(branch.BranchFormat):
 
892
 
 
893
    def __eq__(self, other):
 
894
        return (isinstance(other, RemoteBranchFormat) and 
 
895
            self.__dict__ == other.__dict__)
 
896
 
 
897
    def get_format_description(self):
 
898
        return 'Remote BZR Branch'
 
899
 
 
900
    def get_format_string(self):
 
901
        return 'Remote BZR Branch'
 
902
 
 
903
    def open(self, a_bzrdir):
 
904
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
905
        return a_bzrdir.open_branch()
 
906
 
 
907
    def initialize(self, a_bzrdir):
 
908
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
909
        return a_bzrdir.create_branch()
 
910
 
 
911
    def supports_tags(self):
 
912
        # Remote branches might support tags, but we won't know until we
 
913
        # access the real remote branch.
 
914
        return True
 
915
 
 
916
 
 
917
class RemoteBranch(branch.Branch):
 
918
    """Branch stored on a server accessed by HPSS RPC.
 
919
 
 
920
    At the moment most operations are mapped down to simple file operations.
 
921
    """
 
922
 
 
923
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
 
924
        _client=None):
 
925
        """Create a RemoteBranch instance.
 
926
 
 
927
        :param real_branch: An optional local implementation of the branch
 
928
            format, usually accessing the data via the VFS.
 
929
        :param _client: Private parameter for testing.
 
930
        """
 
931
        # We intentionally don't call the parent class's __init__, because it
 
932
        # will try to assign to self.tags, which is a property in this subclass.
 
933
        # And the parent's __init__ doesn't do much anyway.
 
934
        self._revision_history_cache = None
 
935
        self.bzrdir = remote_bzrdir
 
936
        if _client is not None:
 
937
            self._client = _client
 
938
        else:
 
939
            self._client = client._SmartClient(self.bzrdir._shared_medium)
 
940
        self.repository = remote_repository
 
941
        if real_branch is not None:
 
942
            self._real_branch = real_branch
 
943
            # Give the remote repository the matching real repo.
 
944
            real_repo = self._real_branch.repository
 
945
            if isinstance(real_repo, RemoteRepository):
 
946
                real_repo._ensure_real()
 
947
                real_repo = real_repo._real_repository
 
948
            self.repository._set_real_repository(real_repo)
 
949
            # Give the branch the remote repository to let fast-pathing happen.
 
950
            self._real_branch.repository = self.repository
 
951
        else:
 
952
            self._real_branch = None
 
953
        # Fill out expected attributes of branch for bzrlib api users.
 
954
        self._format = RemoteBranchFormat()
 
955
        self.base = self.bzrdir.root_transport.base
 
956
        self._control_files = None
 
957
        self._lock_mode = None
 
958
        self._lock_token = None
 
959
        self._lock_count = 0
 
960
        self._leave_lock = False
 
961
 
 
962
    def __str__(self):
 
963
        return "%s(%s)" % (self.__class__.__name__, self.base)
 
964
 
 
965
    __repr__ = __str__
 
966
 
 
967
    def _ensure_real(self):
 
968
        """Ensure that there is a _real_branch set.
 
969
 
 
970
        Used before calls to self._real_branch.
 
971
        """
 
972
        if not self._real_branch:
 
973
            assert vfs.vfs_enabled()
 
974
            self.bzrdir._ensure_real()
 
975
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
 
976
            # Give the remote repository the matching real repo.
 
977
            real_repo = self._real_branch.repository
 
978
            if isinstance(real_repo, RemoteRepository):
 
979
                real_repo._ensure_real()
 
980
                real_repo = real_repo._real_repository
 
981
            self.repository._set_real_repository(real_repo)
 
982
            # Give the branch the remote repository to let fast-pathing happen.
 
983
            self._real_branch.repository = self.repository
 
984
            # XXX: deal with _lock_mode == 'w'
 
985
            if self._lock_mode == 'r':
 
986
                self._real_branch.lock_read()
 
987
 
 
988
    @property
 
989
    def control_files(self):
 
990
        # Defer actually creating RemoteBranchLockableFiles until its needed,
 
991
        # because it triggers an _ensure_real that we otherwise might not need.
 
992
        if self._control_files is None:
 
993
            self._control_files = RemoteBranchLockableFiles(
 
994
                self.bzrdir, self._client)
 
995
        return self._control_files
 
996
 
 
997
    def _get_checkout_format(self):
 
998
        self._ensure_real()
 
999
        return self._real_branch._get_checkout_format()
 
1000
 
 
1001
    def get_physical_lock_status(self):
 
1002
        """See Branch.get_physical_lock_status()."""
 
1003
        # should be an API call to the server, as branches must be lockable.
 
1004
        self._ensure_real()
 
1005
        return self._real_branch.get_physical_lock_status()
 
1006
 
 
1007
    def lock_read(self):
 
1008
        if not self._lock_mode:
 
1009
            self._lock_mode = 'r'
 
1010
            self._lock_count = 1
 
1011
            if self._real_branch is not None:
 
1012
                self._real_branch.lock_read()
 
1013
        else:
 
1014
            self._lock_count += 1
 
1015
 
 
1016
    def _remote_lock_write(self, token):
 
1017
        if token is None:
 
1018
            branch_token = repo_token = ''
 
1019
        else:
 
1020
            branch_token = token
 
1021
            repo_token = self.repository.lock_write()
 
1022
            self.repository.unlock()
 
1023
        path = self.bzrdir._path_for_remote_call(self._client)
 
1024
        response = self._client.call('Branch.lock_write', path, branch_token,
 
1025
                                     repo_token)
 
1026
        if response[0] == 'ok':
 
1027
            ok, branch_token, repo_token = response
 
1028
            return branch_token, repo_token
 
1029
        elif response[0] == 'LockContention':
 
1030
            raise errors.LockContention('(remote lock)')
 
1031
        elif response[0] == 'TokenMismatch':
 
1032
            raise errors.TokenMismatch(token, '(remote token)')
 
1033
        elif response[0] == 'UnlockableTransport':
 
1034
            raise errors.UnlockableTransport(self.bzrdir.root_transport)
 
1035
        elif response[0] == 'ReadOnlyError':
 
1036
            raise errors.ReadOnlyError(self)
 
1037
        elif response[0] == 'LockFailed':
 
1038
            raise errors.LockFailed(response[1], response[2])
 
1039
        else:
 
1040
            raise errors.UnexpectedSmartServerResponse(response)
 
1041
            
 
1042
    def lock_write(self, token=None):
 
1043
        if not self._lock_mode:
 
1044
            remote_tokens = self._remote_lock_write(token)
 
1045
            self._lock_token, self._repo_lock_token = remote_tokens
 
1046
            assert self._lock_token, 'Remote server did not return a token!'
 
1047
            # TODO: We really, really, really don't want to call _ensure_real
 
1048
            # here, but it's the easiest way to ensure coherency between the
 
1049
            # state of the RemoteBranch and RemoteRepository objects and the
 
1050
            # physical locks.  If we don't materialise the real objects here,
 
1051
            # then getting everything in the right state later is complex, so
 
1052
            # for now we just do it the lazy way.
 
1053
            #   -- Andrew Bennetts, 2007-02-22.
 
1054
            self._ensure_real()
 
1055
            if self._real_branch is not None:
 
1056
                self._real_branch.repository.lock_write(
 
1057
                    token=self._repo_lock_token)
 
1058
                try:
 
1059
                    self._real_branch.lock_write(token=self._lock_token)
 
1060
                finally:
 
1061
                    self._real_branch.repository.unlock()
 
1062
            if token is not None:
 
1063
                self._leave_lock = True
 
1064
            else:
 
1065
                # XXX: this case seems to be unreachable; token cannot be None.
 
1066
                self._leave_lock = False
 
1067
            self._lock_mode = 'w'
 
1068
            self._lock_count = 1
 
1069
        elif self._lock_mode == 'r':
 
1070
            raise errors.ReadOnlyTransaction
 
1071
        else:
 
1072
            if token is not None:
 
1073
                # A token was given to lock_write, and we're relocking, so check
 
1074
                # that the given token actually matches the one we already have.
 
1075
                if token != self._lock_token:
 
1076
                    raise errors.TokenMismatch(token, self._lock_token)
 
1077
            self._lock_count += 1
 
1078
        return self._lock_token
 
1079
 
 
1080
    def _unlock(self, branch_token, repo_token):
 
1081
        path = self.bzrdir._path_for_remote_call(self._client)
 
1082
        response = self._client.call('Branch.unlock', path, branch_token,
 
1083
                                     repo_token)
 
1084
        if response == ('ok',):
 
1085
            return
 
1086
        elif response[0] == 'TokenMismatch':
 
1087
            raise errors.TokenMismatch(
 
1088
                str((branch_token, repo_token)), '(remote tokens)')
 
1089
        else:
 
1090
            raise errors.UnexpectedSmartServerResponse(response)
 
1091
 
 
1092
    def unlock(self):
 
1093
        self._lock_count -= 1
 
1094
        if not self._lock_count:
 
1095
            self._clear_cached_state()
 
1096
            mode = self._lock_mode
 
1097
            self._lock_mode = None
 
1098
            if self._real_branch is not None:
 
1099
                if not self._leave_lock:
 
1100
                    # If this RemoteBranch will remove the physical lock for the
 
1101
                    # repository, make sure the _real_branch doesn't do it
 
1102
                    # first.  (Because the _real_branch's repository is set to
 
1103
                    # be the RemoteRepository.)
 
1104
                    self._real_branch.repository.leave_lock_in_place()
 
1105
                self._real_branch.unlock()
 
1106
            if mode != 'w':
 
1107
                # Only write-locked branched need to make a remote method call
 
1108
                # to perfom the unlock.
 
1109
                return
 
1110
            assert self._lock_token, 'Locked, but no token!'
 
1111
            branch_token = self._lock_token
 
1112
            repo_token = self._repo_lock_token
 
1113
            self._lock_token = None
 
1114
            self._repo_lock_token = None
 
1115
            if not self._leave_lock:
 
1116
                self._unlock(branch_token, repo_token)
 
1117
 
 
1118
    def break_lock(self):
 
1119
        self._ensure_real()
 
1120
        return self._real_branch.break_lock()
 
1121
 
 
1122
    def leave_lock_in_place(self):
 
1123
        self._leave_lock = True
 
1124
 
 
1125
    def dont_leave_lock_in_place(self):
 
1126
        self._leave_lock = False
 
1127
 
 
1128
    def last_revision_info(self):
 
1129
        """See Branch.last_revision_info()."""
 
1130
        path = self.bzrdir._path_for_remote_call(self._client)
 
1131
        response = self._client.call('Branch.last_revision_info', path)
 
1132
        assert response[0] == 'ok', 'unexpected response code %s' % (response,)
 
1133
        revno = int(response[1])
 
1134
        last_revision = response[2]
 
1135
        return (revno, last_revision)
 
1136
 
 
1137
    def _gen_revision_history(self):
 
1138
        """See Branch._gen_revision_history()."""
 
1139
        path = self.bzrdir._path_for_remote_call(self._client)
 
1140
        response = self._client.call_expecting_body(
 
1141
            'Branch.revision_history', path)
 
1142
        assert response[0][0] == 'ok', ('unexpected response code %s'
 
1143
                                        % (response[0],))
 
1144
        result = response[1].read_body_bytes().split('\x00')
 
1145
        if result == ['']:
 
1146
            return []
 
1147
        return result
 
1148
 
 
1149
    @needs_write_lock
 
1150
    def set_revision_history(self, rev_history):
 
1151
        # Send just the tip revision of the history; the server will generate
 
1152
        # the full history from that.  If the revision doesn't exist in this
 
1153
        # branch, NoSuchRevision will be raised.
 
1154
        path = self.bzrdir._path_for_remote_call(self._client)
 
1155
        if rev_history == []:
 
1156
            rev_id = 'null:'
 
1157
        else:
 
1158
            rev_id = rev_history[-1]
 
1159
        self._clear_cached_state()
 
1160
        response = self._client.call('Branch.set_last_revision',
 
1161
            path, self._lock_token, self._repo_lock_token, rev_id)
 
1162
        if response[0] == 'NoSuchRevision':
 
1163
            raise NoSuchRevision(self, rev_id)
 
1164
        else:
 
1165
            assert response == ('ok',), (
 
1166
                'unexpected response code %r' % (response,))
 
1167
        self._cache_revision_history(rev_history)
 
1168
 
 
1169
    def get_parent(self):
 
1170
        self._ensure_real()
 
1171
        return self._real_branch.get_parent()
 
1172
        
 
1173
    def set_parent(self, url):
 
1174
        self._ensure_real()
 
1175
        return self._real_branch.set_parent(url)
 
1176
        
 
1177
    def get_config(self):
 
1178
        return RemoteBranchConfig(self)
 
1179
 
 
1180
    def sprout(self, to_bzrdir, revision_id=None):
 
1181
        # Like Branch.sprout, except that it sprouts a branch in the default
 
1182
        # format, because RemoteBranches can't be created at arbitrary URLs.
 
1183
        # XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
 
1184
        # to_bzrdir.create_branch...
 
1185
        result = branch.BranchFormat.get_default_format().initialize(to_bzrdir)
 
1186
        self.copy_content_into(result, revision_id=revision_id)
 
1187
        result.set_parent(self.bzrdir.root_transport.base)
 
1188
        return result
 
1189
 
 
1190
    @needs_write_lock
 
1191
    def pull(self, source, overwrite=False, stop_revision=None,
 
1192
             **kwargs):
 
1193
        # FIXME: This asks the real branch to run the hooks, which means
 
1194
        # they're called with the wrong target branch parameter. 
 
1195
        # The test suite specifically allows this at present but it should be
 
1196
        # fixed.  It should get a _override_hook_target branch,
 
1197
        # as push does.  -- mbp 20070405
 
1198
        self._ensure_real()
 
1199
        self._real_branch.pull(
 
1200
            source, overwrite=overwrite, stop_revision=stop_revision,
 
1201
            **kwargs)
 
1202
 
 
1203
    @needs_read_lock
 
1204
    def push(self, target, overwrite=False, stop_revision=None):
 
1205
        self._ensure_real()
 
1206
        return self._real_branch.push(
 
1207
            target, overwrite=overwrite, stop_revision=stop_revision,
 
1208
            _override_hook_source_branch=self)
 
1209
 
 
1210
    def is_locked(self):
 
1211
        return self._lock_count >= 1
 
1212
 
 
1213
    def set_last_revision_info(self, revno, revision_id):
 
1214
        self._ensure_real()
 
1215
        self._clear_cached_state()
 
1216
        return self._real_branch.set_last_revision_info(revno, revision_id)
 
1217
 
 
1218
    def generate_revision_history(self, revision_id, last_rev=None,
 
1219
                                  other_branch=None):
 
1220
        self._ensure_real()
 
1221
        return self._real_branch.generate_revision_history(
 
1222
            revision_id, last_rev=last_rev, other_branch=other_branch)
 
1223
 
 
1224
    @property
 
1225
    def tags(self):
 
1226
        self._ensure_real()
 
1227
        return self._real_branch.tags
 
1228
 
 
1229
    def set_push_location(self, location):
 
1230
        self._ensure_real()
 
1231
        return self._real_branch.set_push_location(location)
 
1232
 
 
1233
    def update_revisions(self, other, stop_revision=None):
 
1234
        self._ensure_real()
 
1235
        return self._real_branch.update_revisions(
 
1236
            other, stop_revision=stop_revision)
 
1237
 
 
1238
 
 
1239
class RemoteBranchConfig(BranchConfig):
 
1240
 
 
1241
    def username(self):
 
1242
        self.branch._ensure_real()
 
1243
        return self.branch._real_branch.get_config().username()
 
1244
 
 
1245
    def _get_branch_data_config(self):
 
1246
        self.branch._ensure_real()
 
1247
        if self._branch_data_config is None:
 
1248
            self._branch_data_config = TreeConfig(self.branch._real_branch)
 
1249
        return self._branch_data_config
 
1250
 
 
1251
 
 
1252
def _extract_tar(tar, to_dir):
 
1253
    """Extract all the contents of a tarfile object.
 
1254
 
 
1255
    A replacement for extractall, which is not present in python2.4
 
1256
    """
 
1257
    for tarinfo in tar:
 
1258
        tar.extract(tarinfo, to_dir)