/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

  • Committer: Andrew Bennetts
  • Date: 2009-07-27 02:11:25 UTC
  • mto: This revision was merged to the branch mainline in revision 4573.
  • Revision ID: andrew.bennetts@canonical.com-20090727021125-ohf358magl25s786
Update test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
# TODO: At some point, handle upgrades by just passing the whole request
 
18
# across to run on the server.
 
19
 
17
20
import bz2
18
21
 
19
22
from bzrlib import (
24
27
    debug,
25
28
    errors,
26
29
    graph,
27
 
    lock,
28
30
    lockdir,
29
31
    repository,
30
 
    repository as _mod_repository,
31
32
    revision,
32
33
    revision as _mod_revision,
33
 
    static_tuple,
34
34
    symbol_versioning,
35
35
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
36
from bzrlib.branch import BranchReferenceFormat
37
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
39
from bzrlib.errors import (
40
40
    NoSuchRevision,
41
41
    SmartProtocolError,
43
43
from bzrlib.lockable_files import LockableFiles
44
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
45
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
46
from bzrlib.trace import mutter, note, warning
48
47
 
49
48
 
92
91
class RemoteBzrDir(BzrDir, _RpcHelper):
93
92
    """Control directory on a remote server, accessed via bzr:// or similar."""
94
93
 
95
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
94
    def __init__(self, transport, format, _client=None):
96
95
        """Construct a RemoteBzrDir.
97
96
 
98
97
        :param _client: Private parameter for testing. Disables probing and the
102
101
        # this object holds a delegated bzrdir that uses file-level operations
103
102
        # to talk to the other side
104
103
        self._real_bzrdir = None
105
 
        self._has_working_tree = None
106
104
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
105
        # create_branch for details.
108
106
        self._next_open_branch_result = None
112
110
            self._client = client._SmartClient(medium)
113
111
        else:
114
112
            self._client = _client
115
 
            if not _force_probe:
116
 
                return
117
 
 
118
 
        self._probe_bzrdir()
119
 
 
120
 
    def __repr__(self):
121
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
122
 
 
123
 
    def _probe_bzrdir(self):
124
 
        medium = self._client._medium
 
113
            return
 
114
 
125
115
        path = self._path_for_remote_call(self._client)
126
 
        if medium._is_remote_before((2, 1)):
127
 
            self._rpc_open(path)
128
 
            return
129
 
        try:
130
 
            self._rpc_open_2_1(path)
131
 
            return
132
 
        except errors.UnknownSmartMethod:
133
 
            medium._remember_remote_is_before((2, 1))
134
 
            self._rpc_open(path)
135
 
 
136
 
    def _rpc_open_2_1(self, path):
137
 
        response = self._call('BzrDir.open_2.1', path)
138
 
        if response == ('no',):
139
 
            raise errors.NotBranchError(path=self.root_transport.base)
140
 
        elif response[0] == 'yes':
141
 
            if response[1] == 'yes':
142
 
                self._has_working_tree = True
143
 
            elif response[1] == 'no':
144
 
                self._has_working_tree = False
145
 
            else:
146
 
                raise errors.UnexpectedSmartServerResponse(response)
147
 
        else:
148
 
            raise errors.UnexpectedSmartServerResponse(response)
149
 
 
150
 
    def _rpc_open(self, path):
151
116
        response = self._call('BzrDir.open', path)
152
117
        if response not in [('yes',), ('no',)]:
153
118
            raise errors.UnexpectedSmartServerResponse(response)
154
119
        if response == ('no',):
155
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
120
            raise errors.NotBranchError(path=transport.base)
156
121
 
157
122
    def _ensure_real(self):
158
123
        """Ensure that there is a _real_bzrdir set.
160
125
        Used before calls to self._real_bzrdir.
161
126
        """
162
127
        if not self._real_bzrdir:
163
 
            if 'hpssvfs' in debug.debug_flags:
164
 
                import traceback
165
 
                warning('VFS BzrDir access triggered\n%s',
166
 
                    ''.join(traceback.format_stack()))
167
128
            self._real_bzrdir = BzrDir.open_from_transport(
168
129
                self.root_transport, _server_formats=False)
169
130
            self._format._network_name = \
245
206
        self._ensure_real()
246
207
        self._real_bzrdir.destroy_repository()
247
208
 
248
 
    def create_branch(self, name=None):
 
209
    def create_branch(self):
249
210
        # as per meta1 formats - just delegate to the format object which may
250
211
        # be parameterised.
251
 
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
212
        real_branch = self._format.get_branch_format().initialize(self)
253
213
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
214
            result = RemoteBranch(self, self.find_repository(), real_branch)
256
215
        else:
257
216
            result = real_branch
258
217
        # BzrDir.clone_on_transport() uses the result of create_branch but does
264
223
        self._next_open_branch_result = result
265
224
        return result
266
225
 
267
 
    def destroy_branch(self, name=None):
 
226
    def destroy_branch(self):
268
227
        """See BzrDir.destroy_branch"""
269
228
        self._ensure_real()
270
 
        self._real_bzrdir.destroy_branch(name=name)
 
229
        self._real_bzrdir.destroy_branch()
271
230
        self._next_open_branch_result = None
272
231
 
273
232
    def create_workingtree(self, revision_id=None, from_branch=None):
274
233
        raise errors.NotLocalUrl(self.transport.base)
275
234
 
276
 
    def find_branch_format(self, name=None):
 
235
    def find_branch_format(self):
277
236
        """Find the branch 'format' for this bzrdir.
278
237
 
279
238
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
239
        """
281
 
        b = self.open_branch(name=name)
 
240
        b = self.open_branch()
282
241
        return b._format
283
242
 
284
 
    def get_branch_reference(self, name=None):
 
243
    def get_branch_reference(self):
285
244
        """See BzrDir.get_branch_reference()."""
286
 
        if name is not None:
287
 
            # XXX JRV20100304: Support opening colocated branches
288
 
            raise errors.NoColocatedBranchSupport(self)
289
245
        response = self._get_branch_reference()
290
246
        if response[0] == 'ref':
291
247
            return response[1]
295
251
    def _get_branch_reference(self):
296
252
        path = self._path_for_remote_call(self._client)
297
253
        medium = self._client._medium
298
 
        candidate_calls = [
299
 
            ('BzrDir.open_branchV3', (2, 1)),
300
 
            ('BzrDir.open_branchV2', (1, 13)),
301
 
            ('BzrDir.open_branch', None),
302
 
            ]
303
 
        for verb, required_version in candidate_calls:
304
 
            if required_version and medium._is_remote_before(required_version):
305
 
                continue
 
254
        if not medium._is_remote_before((1, 13)):
306
255
            try:
307
 
                response = self._call(verb, path)
 
256
                response = self._call('BzrDir.open_branchV2', path)
 
257
                if response[0] not in ('ref', 'branch'):
 
258
                    raise errors.UnexpectedSmartServerResponse(response)
 
259
                return response
308
260
            except errors.UnknownSmartMethod:
309
 
                if required_version is None:
310
 
                    raise
311
 
                medium._remember_remote_is_before(required_version)
312
 
            else:
313
 
                break
314
 
        if verb == 'BzrDir.open_branch':
315
 
            if response[0] != 'ok':
316
 
                raise errors.UnexpectedSmartServerResponse(response)
317
 
            if response[1] != '':
318
 
                return ('ref', response[1])
319
 
            else:
320
 
                return ('branch', '')
321
 
        if response[0] not in ('ref', 'branch'):
 
261
                medium._remember_remote_is_before((1, 13))
 
262
        response = self._call('BzrDir.open_branch', path)
 
263
        if response[0] != 'ok':
322
264
            raise errors.UnexpectedSmartServerResponse(response)
323
 
        return response
 
265
        if response[1] != '':
 
266
            return ('ref', response[1])
 
267
        else:
 
268
            return ('branch', '')
324
269
 
325
 
    def _get_tree_branch(self, name=None):
 
270
    def _get_tree_branch(self):
326
271
        """See BzrDir._get_tree_branch()."""
327
 
        return None, self.open_branch(name=name)
 
272
        return None, self.open_branch()
328
273
 
329
 
    def open_branch(self, name=None, unsupported=False,
330
 
                    ignore_fallbacks=False):
331
 
        if unsupported:
 
274
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
275
        if _unsupported:
332
276
            raise NotImplementedError('unsupported flag support not implemented yet.')
333
277
        if self._next_open_branch_result is not None:
334
278
            # See create_branch for details.
339
283
        if response[0] == 'ref':
340
284
            # a branch reference, use the existing BranchReference logic.
341
285
            format = BranchReferenceFormat()
342
 
            return format.open(self, name=name, _found=True,
343
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
286
            return format.open(self, _found=True, location=response[1],
 
287
                ignore_fallbacks=ignore_fallbacks)
344
288
        branch_format_name = response[1]
345
289
        if not branch_format_name:
346
290
            branch_format_name = None
347
291
        format = RemoteBranchFormat(network_name=branch_format_name)
348
292
        return RemoteBranch(self, self.find_repository(), format=format,
349
 
            setup_stacking=not ignore_fallbacks, name=name)
 
293
            setup_stacking=not ignore_fallbacks)
350
294
 
351
295
    def _open_repo_v1(self, path):
352
296
        verb = 'BzrDir.find_repository'
413
357
        else:
414
358
            raise errors.NoRepositoryPresent(self)
415
359
 
416
 
    def has_workingtree(self):
417
 
        if self._has_working_tree is None:
418
 
            self._ensure_real()
419
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
420
 
        return self._has_working_tree
421
 
 
422
360
    def open_workingtree(self, recommend_upgrade=True):
423
 
        if self.has_workingtree():
 
361
        self._ensure_real()
 
362
        if self._real_bzrdir.has_workingtree():
424
363
            raise errors.NotLocalUrl(self.root_transport)
425
364
        else:
426
365
            raise errors.NoWorkingTree(self.root_transport.base)
429
368
        """Return the path to be used for this bzrdir in a remote call."""
430
369
        return client.remote_path_from_transport(self.root_transport)
431
370
 
432
 
    def get_branch_transport(self, branch_format, name=None):
 
371
    def get_branch_transport(self, branch_format):
433
372
        self._ensure_real()
434
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
373
        return self._real_bzrdir.get_branch_transport(branch_format)
435
374
 
436
375
    def get_repository_transport(self, repository_format):
437
376
        self._ensure_real()
489
428
        self._custom_format = None
490
429
        self._network_name = None
491
430
        self._creating_bzrdir = None
492
 
        self._supports_chks = None
493
431
        self._supports_external_lookups = None
494
432
        self._supports_tree_reference = None
495
433
        self._rich_root_data = None
496
434
 
497
 
    def __repr__(self):
498
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
499
 
            self._network_name)
500
 
 
501
435
    @property
502
436
    def fast_deltas(self):
503
437
        self._ensure_real()
511
445
        return self._rich_root_data
512
446
 
513
447
    @property
514
 
    def supports_chks(self):
515
 
        if self._supports_chks is None:
516
 
            self._ensure_real()
517
 
            self._supports_chks = self._custom_format.supports_chks
518
 
        return self._supports_chks
519
 
 
520
 
    @property
521
448
    def supports_external_lookups(self):
522
449
        if self._supports_external_lookups is None:
523
450
            self._ensure_real()
624
551
        return self._custom_format._fetch_reconcile
625
552
 
626
553
    def get_format_description(self):
627
 
        self._ensure_real()
628
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
554
        return 'bzr remote repository'
629
555
 
630
556
    def __eq__(self, other):
631
557
        return self.__class__ is other.__class__
632
558
 
 
559
    def check_conversion_target(self, target_format):
 
560
        if self.rich_root_data and not target_format.rich_root_data:
 
561
            raise errors.BadConversionTarget(
 
562
                'Does not support rich root data.', target_format)
 
563
        if (self.supports_tree_reference and
 
564
            not getattr(target_format, 'supports_tree_reference', False)):
 
565
            raise errors.BadConversionTarget(
 
566
                'Does not support nested trees', target_format)
 
567
 
633
568
    def network_name(self):
634
569
        if self._network_name:
635
570
            return self._network_name
647
582
        return self._custom_format._serializer
648
583
 
649
584
 
650
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
 
    bzrdir.ControlComponent):
 
585
class RemoteRepository(_RpcHelper):
652
586
    """Repository accessed over rpc.
653
587
 
654
588
    For the moment most operations are performed using local transport-backed
697
631
        # Additional places to query for data.
698
632
        self._fallback_repositories = []
699
633
 
700
 
    @property
701
 
    def user_transport(self):
702
 
        return self.bzrdir.user_transport
703
 
 
704
 
    @property
705
 
    def control_transport(self):
706
 
        # XXX: Normally you shouldn't directly get at the remote repository
707
 
        # transport, but I'm not sure it's worth making this method
708
 
        # optional -- mbp 2010-04-21
709
 
        return self.bzrdir.get_repository_transport(None)
710
 
        
711
634
    def __str__(self):
712
635
        return "%s(%s)" % (self.__class__.__name__, self.base)
713
636
 
896
819
            result.add(_mod_revision.NULL_REVISION)
897
820
        return result
898
821
 
899
 
    def _has_same_fallbacks(self, other_repo):
900
 
        """Returns true if the repositories have the same fallbacks."""
901
 
        # XXX: copied from Repository; it should be unified into a base class
902
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
903
 
        my_fb = self._fallback_repositories
904
 
        other_fb = other_repo._fallback_repositories
905
 
        if len(my_fb) != len(other_fb):
906
 
            return False
907
 
        for f, g in zip(my_fb, other_fb):
908
 
            if not f.has_same_location(g):
909
 
                return False
910
 
        return True
911
 
 
912
822
    def has_same_location(self, other):
913
 
        # TODO: Move to RepositoryBase and unify with the regular Repository
914
 
        # one; unfortunately the tests rely on slightly different behaviour at
915
 
        # present -- mbp 20090710
916
823
        return (self.__class__ is other.__class__ and
917
824
                self.bzrdir.transport.base == other.bzrdir.transport.base)
918
825
 
921
828
        parents_provider = self._make_parents_provider(other_repository)
922
829
        return graph.Graph(parents_provider)
923
830
 
924
 
    @needs_read_lock
925
 
    def get_known_graph_ancestry(self, revision_ids):
926
 
        """Return the known graph for a set of revision ids and their ancestors.
927
 
        """
928
 
        st = static_tuple.StaticTuple
929
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
930
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
931
 
        return graph.GraphThunkIdsToKeys(known_graph)
932
 
 
933
831
    def gather_stats(self, revid=None, committers=None):
934
832
        """See Repository.gather_stats()."""
935
833
        path = self.bzrdir._path_for_remote_call(self._client)
995
893
    def is_write_locked(self):
996
894
        return self._lock_mode == 'w'
997
895
 
998
 
    def _warn_if_deprecated(self, branch=None):
999
 
        # If we have a real repository, the check will be done there, if we
1000
 
        # don't the check will be done remotely.
1001
 
        pass
1002
 
 
1003
896
    def lock_read(self):
1004
 
        """Lock the repository for read operations.
1005
 
 
1006
 
        :return: A bzrlib.lock.LogicalLockResult.
1007
 
        """
1008
897
        # wrong eventually - want a local lock cache context
1009
898
        if not self._lock_mode:
1010
 
            self._note_lock('r')
1011
899
            self._lock_mode = 'r'
1012
900
            self._lock_count = 1
1013
901
            self._unstacked_provider.enable_cache(cache_misses=True)
1017
905
                repo.lock_read()
1018
906
        else:
1019
907
            self._lock_count += 1
1020
 
        return lock.LogicalLockResult(self.unlock)
1021
908
 
1022
909
    def _remote_lock_write(self, token):
1023
910
        path = self.bzrdir._path_for_remote_call(self._client)
1034
921
 
1035
922
    def lock_write(self, token=None, _skip_rpc=False):
1036
923
        if not self._lock_mode:
1037
 
            self._note_lock('w')
1038
924
            if _skip_rpc:
1039
925
                if self._lock_token is not None:
1040
926
                    if token != self._lock_token:
1063
949
            raise errors.ReadOnlyError(self)
1064
950
        else:
1065
951
            self._lock_count += 1
1066
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
952
        return self._lock_token or None
1067
953
 
1068
954
    def leave_lock_in_place(self):
1069
955
        if not self._lock_token:
1143
1029
        else:
1144
1030
            raise errors.UnexpectedSmartServerResponse(response)
1145
1031
 
1146
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1147
1032
    def unlock(self):
1148
1033
        if not self._lock_count:
1149
 
            return lock.cant_unlock_not_held(self)
 
1034
            raise errors.LockNotHeld(self)
1150
1035
        self._lock_count -= 1
1151
1036
        if self._lock_count > 0:
1152
1037
            return
1249
1134
            # state, so always add a lock here. If a caller passes us a locked
1250
1135
            # repository, they are responsible for unlocking it later.
1251
1136
            repository.lock_read()
1252
 
        self._check_fallback_repository(repository)
1253
1137
        self._fallback_repositories.append(repository)
1254
1138
        # If self._real_repository was parameterised already (e.g. because a
1255
1139
        # _real_branch had its get_stacked_on_url method called), then the
1256
1140
        # repository to be added may already be in the _real_repositories list.
1257
1141
        if self._real_repository is not None:
1258
 
            fallback_locations = [repo.user_url for repo in
 
1142
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1259
1143
                self._real_repository._fallback_repositories]
1260
 
            if repository.user_url not in fallback_locations:
 
1144
            if repository.bzrdir.root_transport.base not in fallback_locations:
1261
1145
                self._real_repository.add_fallback_repository(repository)
1262
1146
 
1263
 
    def _check_fallback_repository(self, repository):
1264
 
        """Check that this repository can fallback to repository safely.
1265
 
 
1266
 
        Raise an error if not.
1267
 
 
1268
 
        :param repository: A repository to fallback to.
1269
 
        """
1270
 
        return _mod_repository.InterRepository._assert_same_model(
1271
 
            self, repository)
1272
 
 
1273
1147
    def add_inventory(self, revid, inv, parents):
1274
1148
        self._ensure_real()
1275
1149
        return self._real_repository.add_inventory(revid, inv, parents)
1276
1150
 
1277
1151
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
 
            parents, basis_inv=None, propagate_caches=False):
 
1152
                               parents):
1279
1153
        self._ensure_real()
1280
1154
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1281
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1282
 
            propagate_caches=propagate_caches)
 
1155
            delta, new_revision_id, parents)
1283
1156
 
1284
1157
    def add_revision(self, rev_id, rev, inv=None, config=None):
1285
1158
        self._ensure_real()
1291
1164
        self._ensure_real()
1292
1165
        return self._real_repository.get_inventory(revision_id)
1293
1166
 
1294
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1167
    def iter_inventories(self, revision_ids):
1295
1168
        self._ensure_real()
1296
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1169
        return self._real_repository.iter_inventories(revision_ids)
1297
1170
 
1298
1171
    @needs_read_lock
1299
1172
    def get_revision(self, revision_id):
1315
1188
        return self._real_repository.make_working_trees()
1316
1189
 
1317
1190
    def refresh_data(self):
1318
 
        """Re-read any data needed to synchronise with disk.
 
1191
        """Re-read any data needed to to synchronise with disk.
1319
1192
 
1320
1193
        This method is intended to be called after another repository instance
1321
1194
        (such as one used by a smart server) has inserted data into the
1322
 
        repository. On all repositories this will work outside of write groups.
1323
 
        Some repository formats (pack and newer for bzrlib native formats)
1324
 
        support refresh_data inside write groups. If called inside a write
1325
 
        group on a repository that does not support refreshing in a write group
1326
 
        IsInWriteGroupError will be raised.
 
1195
        repository. It may not be called during a write group, but may be
 
1196
        called at any other time.
1327
1197
        """
 
1198
        if self.is_in_write_group():
 
1199
            raise errors.InternalBzrError(
 
1200
                "May not refresh_data while in a write group.")
1328
1201
        if self._real_repository is not None:
1329
1202
            self._real_repository.refresh_data()
1330
1203
 
1363
1236
            raise errors.InternalBzrError(
1364
1237
                "May not fetch while in a write group.")
1365
1238
        # fast path same-url fetch operations
1366
 
        if (self.has_same_location(source)
1367
 
            and fetch_spec is None
1368
 
            and self._has_same_fallbacks(source)):
 
1239
        if self.has_same_location(source) and fetch_spec is None:
1369
1240
            # check that last_revision is in 'from' and then return a
1370
1241
            # no-operation.
1371
1242
            if (revision_id is not None and
1544
1415
        return self._real_repository.get_signature_text(revision_id)
1545
1416
 
1546
1417
    @needs_read_lock
1547
 
    def _get_inventory_xml(self, revision_id):
1548
 
        self._ensure_real()
1549
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1418
    def get_inventory_xml(self, revision_id):
 
1419
        self._ensure_real()
 
1420
        return self._real_repository.get_inventory_xml(revision_id)
 
1421
 
 
1422
    def deserialise_inventory(self, revision_id, xml):
 
1423
        self._ensure_real()
 
1424
        return self._real_repository.deserialise_inventory(revision_id, xml)
1550
1425
 
1551
1426
    def reconcile(self, other=None, thorough=False):
1552
1427
        self._ensure_real()
1579
1454
        return self._real_repository.get_revision_reconcile(revision_id)
1580
1455
 
1581
1456
    @needs_read_lock
1582
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1457
    def check(self, revision_ids=None):
1583
1458
        self._ensure_real()
1584
 
        return self._real_repository.check(revision_ids=revision_ids,
1585
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1459
        return self._real_repository.check(revision_ids=revision_ids)
1586
1460
 
1587
1461
    def copy_content_into(self, destination, revision_id=None):
1588
1462
        self._ensure_real()
1628
1502
        return self._real_repository.inventories
1629
1503
 
1630
1504
    @needs_write_lock
1631
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1505
    def pack(self, hint=None):
1632
1506
        """Compress the data within the repository.
1633
1507
 
1634
1508
        This is not currently implemented within the smart server.
1635
1509
        """
1636
1510
        self._ensure_real()
1637
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1511
        return self._real_repository.pack(hint=hint)
1638
1512
 
1639
1513
    @property
1640
1514
    def revisions(self):
1728
1602
        self._ensure_real()
1729
1603
        return self._real_repository.revision_graph_can_have_wrong_parents()
1730
1604
 
1731
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
1605
    def _find_inconsistent_revision_parents(self):
1732
1606
        self._ensure_real()
1733
 
        return self._real_repository._find_inconsistent_revision_parents(
1734
 
            revisions_iterator)
 
1607
        return self._real_repository._find_inconsistent_revision_parents()
1735
1608
 
1736
1609
    def _check_for_inconsistent_revision_parents(self):
1737
1610
        self._ensure_real()
1791
1664
    def insert_stream(self, stream, src_format, resume_tokens):
1792
1665
        target = self.target_repo
1793
1666
        target._unstacked_provider.missing_keys.clear()
1794
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
1667
        if target._lock_token:
1796
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
 
            lock_args = (target._lock_token or '',)
 
1668
            verb = 'Repository.insert_stream_locked'
 
1669
            extra_args = (target._lock_token or '',)
 
1670
            required_version = (1, 14)
1798
1671
        else:
1799
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
1800
 
            lock_args = ()
 
1672
            verb = 'Repository.insert_stream'
 
1673
            extra_args = ()
 
1674
            required_version = (1, 13)
1801
1675
        client = target._client
1802
1676
        medium = client._medium
 
1677
        if medium._is_remote_before(required_version):
 
1678
            # No possible way this can work.
 
1679
            return self._insert_real(stream, src_format, resume_tokens)
1803
1680
        path = target.bzrdir._path_for_remote_call(client)
1804
 
        # Probe for the verb to use with an empty stream before sending the
1805
 
        # real stream to it.  We do this both to avoid the risk of sending a
1806
 
        # large request that is then rejected, and because we don't want to
1807
 
        # implement a way to buffer, rewind, or restart the stream.
1808
 
        found_verb = False
1809
 
        for verb, required_version in candidate_calls:
1810
 
            if medium._is_remote_before(required_version):
1811
 
                continue
1812
 
            if resume_tokens:
1813
 
                # We've already done the probing (and set _is_remote_before) on
1814
 
                # a previous insert.
1815
 
                found_verb = True
1816
 
                break
 
1681
        if not resume_tokens:
 
1682
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1683
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1684
            # fallback to the _real_repositories sink *with a partial stream*.
 
1685
            # Thats bad because we insert less data than bzr expected. To avoid
 
1686
            # this we do a trial push to make sure the verb is accessible, and
 
1687
            # do not fallback when actually pushing the stream. A cleanup patch
 
1688
            # is going to look at rewinding/restarting the stream/partial
 
1689
            # buffering etc.
1817
1690
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1818
1691
            try:
1819
1692
                response = client.call_with_body_stream(
1820
 
                    (verb, path, '') + lock_args, byte_stream)
 
1693
                    (verb, path, '') + extra_args, byte_stream)
1821
1694
            except errors.UnknownSmartMethod:
1822
1695
                medium._remember_remote_is_before(required_version)
1823
 
            else:
1824
 
                found_verb = True
1825
 
                break
1826
 
        if not found_verb:
1827
 
            # Have to use VFS.
1828
 
            return self._insert_real(stream, src_format, resume_tokens)
1829
 
        self._last_inv_record = None
1830
 
        self._last_substream = None
1831
 
        if required_version < (1, 19):
1832
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
1833
 
            # make sure we don't send any.  If the stream contains inventory
1834
 
            # deltas we'll interrupt the smart insert_stream request and
1835
 
            # fallback to VFS.
1836
 
            stream = self._stop_stream_if_inventory_delta(stream)
 
1696
                return self._insert_real(stream, src_format, resume_tokens)
1837
1697
        byte_stream = smart_repo._stream_to_byte_stream(
1838
1698
            stream, src_format)
1839
1699
        resume_tokens = ' '.join(resume_tokens)
1840
1700
        response = client.call_with_body_stream(
1841
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1701
            (verb, path, resume_tokens) + extra_args, byte_stream)
1842
1702
        if response[0][0] not in ('ok', 'missing-basis'):
1843
1703
            raise errors.UnexpectedSmartServerResponse(response)
1844
 
        if self._last_substream is not None:
1845
 
            # The stream included an inventory-delta record, but the remote
1846
 
            # side isn't new enough to support them.  So we need to send the
1847
 
            # rest of the stream via VFS.
1848
 
            self.target_repo.refresh_data()
1849
 
            return self._resume_stream_with_vfs(response, src_format)
1850
1704
        if response[0][0] == 'missing-basis':
1851
1705
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
1706
            resume_tokens = tokens
1855
1709
            self.target_repo.refresh_data()
1856
1710
            return [], set()
1857
1711
 
1858
 
    def _resume_stream_with_vfs(self, response, src_format):
1859
 
        """Resume sending a stream via VFS, first resending the record and
1860
 
        substream that couldn't be sent via an insert_stream verb.
1861
 
        """
1862
 
        if response[0][0] == 'missing-basis':
1863
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1864
 
            # Ignore missing_keys, we haven't finished inserting yet
1865
 
        else:
1866
 
            tokens = []
1867
 
        def resume_substream():
1868
 
            # Yield the substream that was interrupted.
1869
 
            for record in self._last_substream:
1870
 
                yield record
1871
 
            self._last_substream = None
1872
 
        def resume_stream():
1873
 
            # Finish sending the interrupted substream
1874
 
            yield ('inventory-deltas', resume_substream())
1875
 
            # Then simply continue sending the rest of the stream.
1876
 
            for substream_kind, substream in self._last_stream:
1877
 
                yield substream_kind, substream
1878
 
        return self._insert_real(resume_stream(), src_format, tokens)
1879
 
 
1880
 
    def _stop_stream_if_inventory_delta(self, stream):
1881
 
        """Normally this just lets the original stream pass-through unchanged.
1882
 
 
1883
 
        However if any 'inventory-deltas' substream occurs it will stop
1884
 
        streaming, and store the interrupted substream and stream in
1885
 
        self._last_substream and self._last_stream so that the stream can be
1886
 
        resumed by _resume_stream_with_vfs.
1887
 
        """
1888
 
                    
1889
 
        stream_iter = iter(stream)
1890
 
        for substream_kind, substream in stream_iter:
1891
 
            if substream_kind == 'inventory-deltas':
1892
 
                self._last_substream = substream
1893
 
                self._last_stream = stream_iter
1894
 
                return
1895
 
            else:
1896
 
                yield substream_kind, substream
1897
 
            
1898
1712
 
1899
1713
class RemoteStreamSource(repository.StreamSource):
1900
1714
    """Stream data from a remote server."""
1903
1717
        if (self.from_repository._fallback_repositories and
1904
1718
            self.to_format._fetch_order == 'topological'):
1905
1719
            return self._real_stream(self.from_repository, search)
1906
 
        sources = []
1907
 
        seen = set()
1908
 
        repos = [self.from_repository]
1909
 
        while repos:
1910
 
            repo = repos.pop(0)
1911
 
            if repo in seen:
1912
 
                continue
1913
 
            seen.add(repo)
1914
 
            repos.extend(repo._fallback_repositories)
1915
 
            sources.append(repo)
1916
 
        return self.missing_parents_chain(search, sources)
1917
 
 
1918
 
    def get_stream_for_missing_keys(self, missing_keys):
1919
 
        self.from_repository._ensure_real()
1920
 
        real_repo = self.from_repository._real_repository
1921
 
        real_source = real_repo._get_source(self.to_format)
1922
 
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1720
        return self.missing_parents_chain(search, [self.from_repository] +
 
1721
            self.from_repository._fallback_repositories)
1923
1722
 
1924
1723
    def _real_stream(self, repo, search):
1925
1724
        """Get a stream for search from repo.
1932
1731
        """
1933
1732
        source = repo._get_source(self.to_format)
1934
1733
        if isinstance(source, RemoteStreamSource):
1935
 
            repo._ensure_real()
1936
 
            source = repo._real_repository._get_source(self.to_format)
 
1734
            return repository.StreamSource.get_stream(source, search)
1937
1735
        return source.get_stream(search)
1938
1736
 
1939
1737
    def _get_stream(self, repo, search):
1956
1754
            return self._real_stream(repo, search)
1957
1755
        client = repo._client
1958
1756
        medium = client._medium
 
1757
        if medium._is_remote_before((1, 13)):
 
1758
            # streaming was added in 1.13
 
1759
            return self._real_stream(repo, search)
1959
1760
        path = repo.bzrdir._path_for_remote_call(client)
1960
 
        search_bytes = repo._serialise_search_result(search)
1961
 
        args = (path, self.to_format.network_name())
1962
 
        candidate_verbs = [
1963
 
            ('Repository.get_stream_1.19', (1, 19)),
1964
 
            ('Repository.get_stream', (1, 13))]
1965
 
        found_verb = False
1966
 
        for verb, version in candidate_verbs:
1967
 
            if medium._is_remote_before(version):
1968
 
                continue
1969
 
            try:
1970
 
                response = repo._call_with_body_bytes_expecting_body(
1971
 
                    verb, args, search_bytes)
1972
 
            except errors.UnknownSmartMethod:
1973
 
                medium._remember_remote_is_before(version)
1974
 
            else:
1975
 
                response_tuple, response_handler = response
1976
 
                found_verb = True
1977
 
                break
1978
 
        if not found_verb:
 
1761
        try:
 
1762
            search_bytes = repo._serialise_search_result(search)
 
1763
            response = repo._call_with_body_bytes_expecting_body(
 
1764
                'Repository.get_stream',
 
1765
                (path, self.to_format.network_name()), search_bytes)
 
1766
            response_tuple, response_handler = response
 
1767
        except errors.UnknownSmartMethod:
 
1768
            medium._remember_remote_is_before((1,13))
1979
1769
            return self._real_stream(repo, search)
1980
1770
        if response_tuple[0] != 'ok':
1981
1771
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1993
1783
        :param search: The overall search to satisfy with streams.
1994
1784
        :param sources: A list of Repository objects to query.
1995
1785
        """
1996
 
        self.from_serialiser = self.from_repository._format._serializer
 
1786
        self.serialiser = self.to_format._serializer
1997
1787
        self.seen_revs = set()
1998
1788
        self.referenced_revs = set()
1999
1789
        # If there are heads in the search, or the key count is > 0, we are not
2016
1806
    def missing_parents_rev_handler(self, substream):
2017
1807
        for content in substream:
2018
1808
            revision_bytes = content.get_bytes_as('fulltext')
2019
 
            revision = self.from_serialiser.read_revision_from_string(
2020
 
                revision_bytes)
 
1809
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2021
1810
            self.seen_revs.add(content.key[-1])
2022
1811
            self.referenced_revs.update(revision.parent_ids)
2023
1812
            yield content
2062
1851
                self._network_name)
2063
1852
 
2064
1853
    def get_format_description(self):
2065
 
        self._ensure_real()
2066
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1854
        return 'Remote BZR Branch'
2067
1855
 
2068
1856
    def network_name(self):
2069
1857
        return self._network_name
2070
1858
 
2071
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2072
 
        return a_bzrdir.open_branch(name=name, 
2073
 
            ignore_fallbacks=ignore_fallbacks)
 
1859
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1860
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2074
1861
 
2075
 
    def _vfs_initialize(self, a_bzrdir, name):
 
1862
    def _vfs_initialize(self, a_bzrdir):
2076
1863
        # Initialisation when using a local bzrdir object, or a non-vfs init
2077
1864
        # method is not available on the server.
2078
1865
        # self._custom_format is always set - the start of initialize ensures
2079
1866
        # that.
2080
1867
        if isinstance(a_bzrdir, RemoteBzrDir):
2081
1868
            a_bzrdir._ensure_real()
2082
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2083
 
                name)
 
1869
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2084
1870
        else:
2085
1871
            # We assume the bzrdir is parameterised; it may not be.
2086
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
1872
            result = self._custom_format.initialize(a_bzrdir)
2087
1873
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2088
1874
            not isinstance(result, RemoteBranch)):
2089
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2090
 
                                  name=name)
 
1875
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2091
1876
        return result
2092
1877
 
2093
 
    def initialize(self, a_bzrdir, name=None):
 
1878
    def initialize(self, a_bzrdir):
2094
1879
        # 1) get the network name to use.
2095
1880
        if self._custom_format:
2096
1881
            network_name = self._custom_format.network_name()
2102
1887
            network_name = reference_format.network_name()
2103
1888
        # Being asked to create on a non RemoteBzrDir:
2104
1889
        if not isinstance(a_bzrdir, RemoteBzrDir):
2105
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1890
            return self._vfs_initialize(a_bzrdir)
2106
1891
        medium = a_bzrdir._client._medium
2107
1892
        if medium._is_remote_before((1, 13)):
2108
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1893
            return self._vfs_initialize(a_bzrdir)
2109
1894
        # Creating on a remote bzr dir.
2110
1895
        # 2) try direct creation via RPC
2111
1896
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2112
 
        if name is not None:
2113
 
            # XXX JRV20100304: Support creating colocated branches
2114
 
            raise errors.NoColocatedBranchSupport(self)
2115
1897
        verb = 'BzrDir.create_branch'
2116
1898
        try:
2117
1899
            response = a_bzrdir._call(verb, path, network_name)
2118
1900
        except errors.UnknownSmartMethod:
2119
1901
            # Fallback - use vfs methods
2120
1902
            medium._remember_remote_is_before((1, 13))
2121
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1903
            return self._vfs_initialize(a_bzrdir)
2122
1904
        if response[0] != 'ok':
2123
1905
            raise errors.UnexpectedSmartServerResponse(response)
2124
1906
        # Turn the response into a RemoteRepository object.
2132
1914
                a_bzrdir._client)
2133
1915
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2134
1916
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2135
 
            format=format, setup_stacking=False, name=name)
 
1917
            format=format, setup_stacking=False)
2136
1918
        # XXX: We know this is a new branch, so it must have revno 0, revid
2137
1919
        # NULL_REVISION. Creating the branch locked would make this be unable
2138
1920
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2158
1940
        return self._custom_format.supports_set_append_revisions_only()
2159
1941
 
2160
1942
 
2161
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1943
class RemoteBranch(branch.Branch, _RpcHelper):
2162
1944
    """Branch stored on a server accessed by HPSS RPC.
2163
1945
 
2164
1946
    At the moment most operations are mapped down to simple file operations.
2165
1947
    """
2166
1948
 
2167
1949
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2168
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1950
        _client=None, format=None, setup_stacking=True):
2169
1951
        """Create a RemoteBranch instance.
2170
1952
 
2171
1953
        :param real_branch: An optional local implementation of the branch
2177
1959
        :param setup_stacking: If True make an RPC call to determine the
2178
1960
            stacked (or not) status of the branch. If False assume the branch
2179
1961
            is not stacked.
2180
 
        :param name: Colocated branch name
2181
1962
        """
2182
1963
        # We intentionally don't call the parent class's __init__, because it
2183
1964
        # will try to assign to self.tags, which is a property in this subclass.
2202
1983
            self._real_branch = None
2203
1984
        # Fill out expected attributes of branch for bzrlib API users.
2204
1985
        self._clear_cached_state()
2205
 
        # TODO: deprecate self.base in favor of user_url
2206
 
        self.base = self.bzrdir.user_url
2207
 
        self._name = name
 
1986
        self.base = self.bzrdir.root_transport.base
2208
1987
        self._control_files = None
2209
1988
        self._lock_mode = None
2210
1989
        self._lock_token = None
2221
2000
                    self._real_branch._format.network_name()
2222
2001
        else:
2223
2002
            self._format = format
2224
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2225
 
        # branch.open_branch method.
2226
 
        self._real_ignore_fallbacks = not setup_stacking
2227
2003
        if not self._format._network_name:
2228
2004
            # Did not get from open_branchV2 - old server.
2229
2005
            self._ensure_real()
2274
2050
                raise AssertionError('smart server vfs must be enabled '
2275
2051
                    'to use vfs implementation')
2276
2052
            self.bzrdir._ensure_real()
2277
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2278
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
2053
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2279
2054
            if self.repository._real_repository is None:
2280
2055
                # Give the remote repository the matching real repo.
2281
2056
                real_repo = self._real_branch.repository
2377
2152
            return self._vfs_get_tags_bytes()
2378
2153
        return response[0]
2379
2154
 
2380
 
    def _vfs_set_tags_bytes(self, bytes):
 
2155
    def _vfs_set_tags_bytes(self):
2381
2156
        self._ensure_real()
2382
 
        return self._real_branch._set_tags_bytes(bytes)
 
2157
        return self._real_branch._set_tags_bytes()
2383
2158
 
2384
2159
    def _set_tags_bytes(self, bytes):
2385
2160
        medium = self._client._medium
2386
2161
        if medium._is_remote_before((1, 18)):
2387
2162
            self._vfs_set_tags_bytes(bytes)
2388
 
            return
2389
2163
        try:
2390
2164
            args = (
2391
2165
                self._remote_path(), self._lock_token, self._repo_lock_token)
2396
2170
            self._vfs_set_tags_bytes(bytes)
2397
2171
 
2398
2172
    def lock_read(self):
2399
 
        """Lock the branch for read operations.
2400
 
 
2401
 
        :return: A bzrlib.lock.LogicalLockResult.
2402
 
        """
2403
2173
        self.repository.lock_read()
2404
2174
        if not self._lock_mode:
2405
 
            self._note_lock('r')
2406
2175
            self._lock_mode = 'r'
2407
2176
            self._lock_count = 1
2408
2177
            if self._real_branch is not None:
2409
2178
                self._real_branch.lock_read()
2410
2179
        else:
2411
2180
            self._lock_count += 1
2412
 
        return lock.LogicalLockResult(self.unlock)
2413
2181
 
2414
2182
    def _remote_lock_write(self, token):
2415
2183
        if token is None:
2416
2184
            branch_token = repo_token = ''
2417
2185
        else:
2418
2186
            branch_token = token
2419
 
            repo_token = self.repository.lock_write().repository_token
 
2187
            repo_token = self.repository.lock_write()
2420
2188
            self.repository.unlock()
2421
2189
        err_context = {'token': token}
2422
2190
        response = self._call(
2429
2197
 
2430
2198
    def lock_write(self, token=None):
2431
2199
        if not self._lock_mode:
2432
 
            self._note_lock('w')
2433
2200
            # Lock the branch and repo in one remote call.
2434
2201
            remote_tokens = self._remote_lock_write(token)
2435
2202
            self._lock_token, self._repo_lock_token = remote_tokens
2459
2226
            self._lock_count += 1
2460
2227
            # Re-lock the repository too.
2461
2228
            self.repository.lock_write(self._repo_lock_token)
2462
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2229
        return self._lock_token or None
2463
2230
 
2464
2231
    def _unlock(self, branch_token, repo_token):
2465
2232
        err_context = {'token': str((branch_token, repo_token))}
2470
2237
            return
2471
2238
        raise errors.UnexpectedSmartServerResponse(response)
2472
2239
 
2473
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2474
2240
    def unlock(self):
2475
2241
        try:
2476
2242
            self._lock_count -= 1
2516
2282
            raise NotImplementedError(self.dont_leave_lock_in_place)
2517
2283
        self._leave_lock = False
2518
2284
 
2519
 
    @needs_read_lock
2520
2285
    def get_rev_id(self, revno, history=None):
2521
2286
        if revno == 0:
2522
2287
            return _mod_revision.NULL_REVISION
2887
2652
                    'Missing key %r in context %r', key_err.args[0], context)
2888
2653
                raise err
2889
2654
 
2890
 
    if err.error_verb == 'IncompatibleRepositories':
2891
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2892
 
            err.error_args[1], err.error_args[2])
2893
 
    elif err.error_verb == 'NoSuchRevision':
 
2655
    if err.error_verb == 'NoSuchRevision':
2894
2656
        raise NoSuchRevision(find('branch'), err.error_args[0])
2895
2657
    elif err.error_verb == 'nosuchrevision':
2896
2658
        raise NoSuchRevision(find('repository'), err.error_args[0])
2897
 
    elif err.error_verb == 'nobranch':
2898
 
        if len(err.error_args) >= 1:
2899
 
            extra = err.error_args[0]
2900
 
        else:
2901
 
            extra = None
2902
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2903
 
            detail=extra)
 
2659
    elif err.error_tuple == ('nobranch',):
 
2660
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2904
2661
    elif err.error_verb == 'norepository':
2905
2662
        raise errors.NoRepositoryPresent(find('bzrdir'))
2906
2663
    elif err.error_verb == 'LockContention':