← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-04 16:06:36 UTC
  • mfrom: (5007 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5023.
  • Revision ID: john@arbash-meinel.com-20100204160636-xqeuwz8bwt8bbts4
Merge bzr.dev 5007, resolve conflict, update NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir as _mod_bzrdir,
 
22
    bzrdir,
23
23
    config,
24
 
    controldir,
25
24
    debug,
26
25
    errors,
27
26
    graph,
28
27
    lock,
29
28
    lockdir,
30
 
    repository as _mod_repository,
 
29
    repository,
 
30
    revision,
31
31
    revision as _mod_revision,
32
 
    static_tuple,
33
32
    symbol_versioning,
34
 
    urlutils,
35
 
    vf_repository,
36
 
    )
37
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
33
)
 
34
from bzrlib.branch import BranchReferenceFormat
 
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
36
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
37
from bzrlib.errors import (
40
38
    NoSuchRevision,
42
40
    )
43
41
from bzrlib.lockable_files import LockableFiles
44
42
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.smart.client import _SmartClient
46
 
from bzrlib.revision import NULL_REVISION
47
 
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
43
from bzrlib.revision import ensure_null, NULL_REVISION
48
44
from bzrlib.trace import mutter, note, warning
49
45
 
50
46
 
88
84
    return format
89
85
 
90
86
 
91
 
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
92
 
# does not have to be imported unless a remote format is involved.
93
 
 
94
 
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
95
 
    """Format representing bzrdirs accessed via a smart server"""
96
 
 
97
 
    supports_workingtrees = False
98
 
 
99
 
    def __init__(self):
100
 
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
101
 
        # XXX: It's a bit ugly that the network name is here, because we'd
102
 
        # like to believe that format objects are stateless or at least
103
 
        # immutable,  However, we do at least avoid mutating the name after
104
 
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
105
 
        self._network_name = None
106
 
 
107
 
    def __repr__(self):
108
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
109
 
            self._network_name)
110
 
 
111
 
    def get_format_description(self):
112
 
        if self._network_name:
113
 
            real_format = controldir.network_format_registry.get(self._network_name)
114
 
            return 'Remote: ' + real_format.get_format_description()
115
 
        return 'bzr remote bzrdir'
116
 
 
117
 
    def get_format_string(self):
118
 
        raise NotImplementedError(self.get_format_string)
119
 
 
120
 
    def network_name(self):
121
 
        if self._network_name:
122
 
            return self._network_name
123
 
        else:
124
 
            raise AssertionError("No network name set.")
125
 
 
126
 
    def initialize_on_transport(self, transport):
127
 
        try:
128
 
            # hand off the request to the smart server
129
 
            client_medium = transport.get_smart_medium()
130
 
        except errors.NoSmartMedium:
131
 
            # TODO: lookup the local format from a server hint.
132
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
133
 
            return local_dir_format.initialize_on_transport(transport)
134
 
        client = _SmartClient(client_medium)
135
 
        path = client.remote_path_from_transport(transport)
136
 
        try:
137
 
            response = client.call('BzrDirFormat.initialize', path)
138
 
        except errors.ErrorFromSmartServer, err:
139
 
            _translate_error(err, path=path)
140
 
        if response[0] != 'ok':
141
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
142
 
        format = RemoteBzrDirFormat()
143
 
        self._supply_sub_formats_to(format)
144
 
        return RemoteBzrDir(transport, format)
145
 
 
146
 
    def parse_NoneTrueFalse(self, arg):
147
 
        if not arg:
148
 
            return None
149
 
        if arg == 'False':
150
 
            return False
151
 
        if arg == 'True':
152
 
            return True
153
 
        raise AssertionError("invalid arg %r" % arg)
154
 
 
155
 
    def _serialize_NoneTrueFalse(self, arg):
156
 
        if arg is False:
157
 
            return 'False'
158
 
        if arg:
159
 
            return 'True'
160
 
        return ''
161
 
 
162
 
    def _serialize_NoneString(self, arg):
163
 
        return arg or ''
164
 
 
165
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
166
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
167
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
168
 
        shared_repo=False):
169
 
        try:
170
 
            # hand off the request to the smart server
171
 
            client_medium = transport.get_smart_medium()
172
 
        except errors.NoSmartMedium:
173
 
            do_vfs = True
174
 
        else:
175
 
            # Decline to open it if the server doesn't support our required
176
 
            # version (3) so that the VFS-based transport will do it.
177
 
            if client_medium.should_probe():
178
 
                try:
179
 
                    server_version = client_medium.protocol_version()
180
 
                    if server_version != '2':
181
 
                        do_vfs = True
182
 
                    else:
183
 
                        do_vfs = False
184
 
                except errors.SmartProtocolError:
185
 
                    # Apparently there's no usable smart server there, even though
186
 
                    # the medium supports the smart protocol.
187
 
                    do_vfs = True
188
 
            else:
189
 
                do_vfs = False
190
 
        if not do_vfs:
191
 
            client = _SmartClient(client_medium)
192
 
            path = client.remote_path_from_transport(transport)
193
 
            if client_medium._is_remote_before((1, 16)):
194
 
                do_vfs = True
195
 
        if do_vfs:
196
 
            # TODO: lookup the local format from a server hint.
197
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
198
 
            self._supply_sub_formats_to(local_dir_format)
199
 
            return local_dir_format.initialize_on_transport_ex(transport,
200
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
201
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
202
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
203
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
204
 
                vfs_only=True)
205
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
206
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
207
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
208
 
 
209
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
210
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
211
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
212
 
        args = []
213
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
214
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
215
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
216
 
        args.append(self._serialize_NoneString(stacked_on))
217
 
        # stack_on_pwd is often/usually our transport
218
 
        if stack_on_pwd:
219
 
            try:
220
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
221
 
                if not stack_on_pwd:
222
 
                    stack_on_pwd = '.'
223
 
            except errors.PathNotChild:
224
 
                pass
225
 
        args.append(self._serialize_NoneString(stack_on_pwd))
226
 
        args.append(self._serialize_NoneString(repo_format_name))
227
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
228
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
229
 
        request_network_name = self._network_name or \
230
 
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
231
 
        try:
232
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
233
 
                request_network_name, path, *args)
234
 
        except errors.UnknownSmartMethod:
235
 
            client._medium._remember_remote_is_before((1,16))
236
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
237
 
            self._supply_sub_formats_to(local_dir_format)
238
 
            return local_dir_format.initialize_on_transport_ex(transport,
239
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
240
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
241
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
242
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
243
 
                vfs_only=True)
244
 
        except errors.ErrorFromSmartServer, err:
245
 
            _translate_error(err, path=path)
246
 
        repo_path = response[0]
247
 
        bzrdir_name = response[6]
248
 
        require_stacking = response[7]
249
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
250
 
        format = RemoteBzrDirFormat()
251
 
        format._network_name = bzrdir_name
252
 
        self._supply_sub_formats_to(format)
253
 
        bzrdir = RemoteBzrDir(transport, format, _client=client)
254
 
        if repo_path:
255
 
            repo_format = response_tuple_to_repo_format(response[1:])
256
 
            if repo_path == '.':
257
 
                repo_path = ''
258
 
            if repo_path:
259
 
                repo_bzrdir_format = RemoteBzrDirFormat()
260
 
                repo_bzrdir_format._network_name = response[5]
261
 
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
262
 
                    repo_bzrdir_format)
263
 
            else:
264
 
                repo_bzr = bzrdir
265
 
            final_stack = response[8] or None
266
 
            final_stack_pwd = response[9] or None
267
 
            if final_stack_pwd:
268
 
                final_stack_pwd = urlutils.join(
269
 
                    transport.base, final_stack_pwd)
270
 
            remote_repo = RemoteRepository(repo_bzr, repo_format)
271
 
            if len(response) > 10:
272
 
                # Updated server verb that locks remotely.
273
 
                repo_lock_token = response[10] or None
274
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
275
 
                if repo_lock_token:
276
 
                    remote_repo.dont_leave_lock_in_place()
277
 
            else:
278
 
                remote_repo.lock_write()
279
 
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
280
 
                final_stack_pwd, require_stacking)
281
 
            policy.acquire_repository()
282
 
        else:
283
 
            remote_repo = None
284
 
            policy = None
285
 
        bzrdir._format.set_branch_format(self.get_branch_format())
286
 
        if require_stacking:
287
 
            # The repo has already been created, but we need to make sure that
288
 
            # we'll make a stackable branch.
289
 
            bzrdir._format.require_stacking(_skip_repo=True)
290
 
        return remote_repo, bzrdir, require_stacking, policy
291
 
 
292
 
    def _open(self, transport):
293
 
        return RemoteBzrDir(transport, self)
294
 
 
295
 
    def __eq__(self, other):
296
 
        if not isinstance(other, RemoteBzrDirFormat):
297
 
            return False
298
 
        return self.get_format_description() == other.get_format_description()
299
 
 
300
 
    def __return_repository_format(self):
301
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
302
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
303
 
        # that it should use that for init() etc.
304
 
        result = RemoteRepositoryFormat()
305
 
        custom_format = getattr(self, '_repository_format', None)
306
 
        if custom_format:
307
 
            if isinstance(custom_format, RemoteRepositoryFormat):
308
 
                return custom_format
309
 
            else:
310
 
                # We will use the custom format to create repositories over the
311
 
                # wire; expose its details like rich_root_data for code to
312
 
                # query
313
 
                result._custom_format = custom_format
314
 
        return result
315
 
 
316
 
    def get_branch_format(self):
317
 
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
318
 
        if not isinstance(result, RemoteBranchFormat):
319
 
            new_result = RemoteBranchFormat()
320
 
            new_result._custom_format = result
321
 
            # cache the result
322
 
            self.set_branch_format(new_result)
323
 
            result = new_result
324
 
        return result
325
 
 
326
 
    repository_format = property(__return_repository_format,
327
 
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
328
 
 
329
 
 
330
 
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
 
87
# Note: RemoteBzrDirFormat is in bzrdir.py
 
88
 
 
89
class RemoteBzrDir(BzrDir, _RpcHelper):
331
90
    """Control directory on a remote server, accessed via bzr:// or similar."""
332
91
 
333
92
    def __init__(self, transport, format, _client=None, _force_probe=False):
336
95
        :param _client: Private parameter for testing. Disables probing and the
337
96
            use of a real bzrdir.
338
97
        """
339
 
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
 
98
        BzrDir.__init__(self, transport, format)
340
99
        # this object holds a delegated bzrdir that uses file-level operations
341
100
        # to talk to the other side
342
101
        self._real_bzrdir = None
402
161
                import traceback
403
162
                warning('VFS BzrDir access triggered\n%s',
404
163
                    ''.join(traceback.format_stack()))
405
 
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
164
            self._real_bzrdir = BzrDir.open_from_transport(
406
165
                self.root_transport, _server_formats=False)
407
166
            self._format._network_name = \
408
167
                self._real_bzrdir._format.network_name()
414
173
        # Prevent aliasing problems in the next_open_branch_result cache.
415
174
        # See create_branch for rationale.
416
175
        self._next_open_branch_result = None
417
 
        return _mod_bzrdir.BzrDir.break_lock(self)
 
176
        return BzrDir.break_lock(self)
418
177
 
419
178
    def _vfs_cloning_metadir(self, require_stacking=False):
420
179
        self._ensure_real()
451
210
        if len(branch_info) != 2:
452
211
            raise errors.UnexpectedSmartServerResponse(response)
453
212
        branch_ref, branch_name = branch_info
454
 
        format = controldir.network_format_registry.get(control_name)
 
213
        format = bzrdir.network_format_registry.get(control_name)
455
214
        if repo_name:
456
 
            format.repository_format = _mod_repository.network_format_registry.get(
 
215
            format.repository_format = repository.network_format_registry.get(
457
216
                repo_name)
458
217
        if branch_ref == 'ref':
459
218
            # XXX: we need possible_transports here to avoid reopening the
460
219
            # connection to the referenced location
461
 
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
 
220
            ref_bzrdir = BzrDir.open(branch_name)
462
221
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
463
222
            format.set_branch_format(branch_format)
464
223
        elif branch_ref == 'branch':
483
242
        self._ensure_real()
484
243
        self._real_bzrdir.destroy_repository()
485
244
 
486
 
    def create_branch(self, name=None, repository=None):
 
245
    def create_branch(self):
487
246
        # as per meta1 formats - just delegate to the format object which may
488
247
        # be parameterised.
489
 
        real_branch = self._format.get_branch_format().initialize(self,
490
 
            name=name, repository=repository)
 
248
        real_branch = self._format.get_branch_format().initialize(self)
491
249
        if not isinstance(real_branch, RemoteBranch):
492
 
            if not isinstance(repository, RemoteRepository):
493
 
                raise AssertionError(
494
 
                    'need a RemoteRepository to use with RemoteBranch, got %r'
495
 
                    % (repository,))
496
 
            result = RemoteBranch(self, repository, real_branch, name=name)
 
250
            result = RemoteBranch(self, self.find_repository(), real_branch)
497
251
        else:
498
252
            result = real_branch
499
253
        # BzrDir.clone_on_transport() uses the result of create_branch but does
505
259
        self._next_open_branch_result = result
506
260
        return result
507
261
 
508
 
    def destroy_branch(self, name=None):
 
262
    def destroy_branch(self):
509
263
        """See BzrDir.destroy_branch"""
510
264
        self._ensure_real()
511
 
        self._real_bzrdir.destroy_branch(name=name)
 
265
        self._real_bzrdir.destroy_branch()
512
266
        self._next_open_branch_result = None
513
267
 
514
 
    def create_workingtree(self, revision_id=None, from_branch=None,
515
 
        accelerator_tree=None, hardlink=False):
 
268
    def create_workingtree(self, revision_id=None, from_branch=None):
516
269
        raise errors.NotLocalUrl(self.transport.base)
517
270
 
518
 
    def find_branch_format(self, name=None):
 
271
    def find_branch_format(self):
519
272
        """Find the branch 'format' for this bzrdir.
520
273
 
521
274
        This might be a synthetic object for e.g. RemoteBranch and SVN.
522
275
        """
523
 
        b = self.open_branch(name=name)
 
276
        b = self.open_branch()
524
277
        return b._format
525
278
 
526
 
    def get_branch_reference(self, name=None):
 
279
    def get_branch_reference(self):
527
280
        """See BzrDir.get_branch_reference()."""
528
 
        if name is not None:
529
 
            # XXX JRV20100304: Support opening colocated branches
530
 
            raise errors.NoColocatedBranchSupport(self)
531
281
        response = self._get_branch_reference()
532
282
        if response[0] == 'ref':
533
283
            return response[1]
564
314
            raise errors.UnexpectedSmartServerResponse(response)
565
315
        return response
566
316
 
567
 
    def _get_tree_branch(self, name=None):
 
317
    def _get_tree_branch(self):
568
318
        """See BzrDir._get_tree_branch()."""
569
 
        return None, self.open_branch(name=name)
 
319
        return None, self.open_branch()
570
320
 
571
 
    def open_branch(self, name=None, unsupported=False,
572
 
                    ignore_fallbacks=False):
573
 
        if unsupported:
 
321
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
322
        if _unsupported:
574
323
            raise NotImplementedError('unsupported flag support not implemented yet.')
575
324
        if self._next_open_branch_result is not None:
576
325
            # See create_branch for details.
581
330
        if response[0] == 'ref':
582
331
            # a branch reference, use the existing BranchReference logic.
583
332
            format = BranchReferenceFormat()
584
 
            return format.open(self, name=name, _found=True,
585
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
333
            return format.open(self, _found=True, location=response[1],
 
334
                ignore_fallbacks=ignore_fallbacks)
586
335
        branch_format_name = response[1]
587
336
        if not branch_format_name:
588
337
            branch_format_name = None
589
338
        format = RemoteBranchFormat(network_name=branch_format_name)
590
339
        return RemoteBranch(self, self.find_repository(), format=format,
591
 
            setup_stacking=not ignore_fallbacks, name=name)
 
340
            setup_stacking=not ignore_fallbacks)
592
341
 
593
342
    def _open_repo_v1(self, path):
594
343
        verb = 'BzrDir.find_repository'
669
418
 
670
419
    def _path_for_remote_call(self, client):
671
420
        """Return the path to be used for this bzrdir in a remote call."""
672
 
        return urlutils.split_segment_parameters_raw(
673
 
            client.remote_path_from_transport(self.root_transport))[0]
 
421
        return client.remote_path_from_transport(self.root_transport)
674
422
 
675
 
    def get_branch_transport(self, branch_format, name=None):
 
423
    def get_branch_transport(self, branch_format):
676
424
        self._ensure_real()
677
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
425
        return self._real_bzrdir.get_branch_transport(branch_format)
678
426
 
679
427
    def get_repository_transport(self, repository_format):
680
428
        self._ensure_real()
688
436
        """Upgrading of remote bzrdirs is not supported yet."""
689
437
        return False
690
438
 
691
 
    def needs_format_conversion(self, format):
 
439
    def needs_format_conversion(self, format=None):
692
440
        """Upgrading of remote bzrdirs is not supported yet."""
 
441
        if format is None:
 
442
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
443
                % 'needs_format_conversion(format=None)')
693
444
        return False
694
445
 
695
446
    def clone(self, url, revision_id=None, force_new_repo=False,
702
453
        return RemoteBzrDirConfig(self)
703
454
 
704
455
 
705
 
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
 
456
class RemoteRepositoryFormat(repository.RepositoryFormat):
706
457
    """Format for repositories accessed over a _SmartClient.
707
458
 
708
459
    Instances of this repository are represented by RemoteRepository
723
474
    """
724
475
 
725
476
    _matchingbzrdir = RemoteBzrDirFormat()
726
 
    supports_full_versioned_files = True
727
 
    supports_leaving_lock = True
728
477
 
729
478
    def __init__(self):
730
 
        _mod_repository.RepositoryFormat.__init__(self)
 
479
        repository.RepositoryFormat.__init__(self)
731
480
        self._custom_format = None
732
481
        self._network_name = None
733
482
        self._creating_bzrdir = None
734
 
        self._revision_graph_can_have_wrong_parents = None
735
483
        self._supports_chks = None
736
484
        self._supports_external_lookups = None
737
485
        self._supports_tree_reference = None
738
 
        self._supports_funky_characters = None
739
486
        self._rich_root_data = None
740
487
 
741
488
    def __repr__(self):
770
517
        return self._supports_external_lookups
771
518
 
772
519
    @property
773
 
    def supports_funky_characters(self):
774
 
        if self._supports_funky_characters is None:
775
 
            self._ensure_real()
776
 
            self._supports_funky_characters = \
777
 
                self._custom_format.supports_funky_characters
778
 
        return self._supports_funky_characters
779
 
 
780
 
    @property
781
520
    def supports_tree_reference(self):
782
521
        if self._supports_tree_reference is None:
783
522
            self._ensure_real()
785
524
                self._custom_format.supports_tree_reference
786
525
        return self._supports_tree_reference
787
526
 
788
 
    @property
789
 
    def revision_graph_can_have_wrong_parents(self):
790
 
        if self._revision_graph_can_have_wrong_parents is None:
791
 
            self._ensure_real()
792
 
            self._revision_graph_can_have_wrong_parents = \
793
 
                self._custom_format.revision_graph_can_have_wrong_parents
794
 
        return self._revision_graph_can_have_wrong_parents
795
 
 
796
527
    def _vfs_initialize(self, a_bzrdir, shared):
797
528
        """Helper for common code in initialize."""
798
529
        if self._custom_format:
833
564
            network_name = self._network_name
834
565
        else:
835
566
            # Select the current bzrlib default and ask for that.
836
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
567
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
837
568
            reference_format = reference_bzrdir_format.repository_format
838
569
            network_name = reference_format.network_name()
839
570
        # 2) try direct creation via RPC
865
596
 
866
597
    def _ensure_real(self):
867
598
        if self._custom_format is None:
868
 
            self._custom_format = _mod_repository.network_format_registry.get(
 
599
            self._custom_format = repository.network_format_registry.get(
869
600
                self._network_name)
870
601
 
871
602
    @property
907
638
        return self._custom_format._serializer
908
639
 
909
640
 
910
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
911
 
    controldir.ControlComponent):
 
641
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
912
642
    """Repository accessed over rpc.
913
643
 
914
644
    For the moment most operations are performed using local transport-backed
957
687
        # Additional places to query for data.
958
688
        self._fallback_repositories = []
959
689
 
960
 
    @property
961
 
    def user_transport(self):
962
 
        return self.bzrdir.user_transport
963
 
 
964
 
    @property
965
 
    def control_transport(self):
966
 
        # XXX: Normally you shouldn't directly get at the remote repository
967
 
        # transport, but I'm not sure it's worth making this method
968
 
        # optional -- mbp 2010-04-21
969
 
        return self.bzrdir.get_repository_transport(None)
970
 
 
971
690
    def __str__(self):
972
691
        return "%s(%s)" % (self.__class__.__name__, self.base)
973
692
 
1081
800
    def find_text_key_references(self):
1082
801
        """Find the text key references within the repository.
1083
802
 
 
803
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
804
        revision_ids. Each altered file-ids has the exact revision_ids that
 
805
        altered it listed explicitly.
1084
806
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1085
807
            to whether they were referred to by the inventory of the
1086
808
            revision_id that they contain. The inventory texts from all present
1104
826
        """Private method for using with old (< 1.2) servers to fallback."""
1105
827
        if revision_id is None:
1106
828
            revision_id = ''
1107
 
        elif _mod_revision.is_null(revision_id):
 
829
        elif revision.is_null(revision_id):
1108
830
            return {}
1109
831
 
1110
832
        path = self.bzrdir._path_for_remote_call(self._client)
1134
856
        return RemoteStreamSource(self, to_format)
1135
857
 
1136
858
    @needs_read_lock
1137
 
    def get_file_graph(self):
1138
 
        return graph.Graph(self.texts)
1139
 
 
1140
 
    @needs_read_lock
1141
859
    def has_revision(self, revision_id):
1142
860
        """True if this repository has a copy of the revision."""
1143
861
        # Copy of bzrlib.repository.Repository.has_revision
1160
878
    def _has_same_fallbacks(self, other_repo):
1161
879
        """Returns true if the repositories have the same fallbacks."""
1162
880
        # XXX: copied from Repository; it should be unified into a base class
1163
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
881
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
1164
882
        my_fb = self._fallback_repositories
1165
883
        other_fb = other_repo._fallback_repositories
1166
884
        if len(my_fb) != len(other_fb):
1182
900
        parents_provider = self._make_parents_provider(other_repository)
1183
901
        return graph.Graph(parents_provider)
1184
902
 
1185
 
    @needs_read_lock
1186
 
    def get_known_graph_ancestry(self, revision_ids):
1187
 
        """Return the known graph for a set of revision ids and their ancestors.
1188
 
        """
1189
 
        st = static_tuple.StaticTuple
1190
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
1191
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
1192
 
        return graph.GraphThunkIdsToKeys(known_graph)
1193
 
 
1194
903
    def gather_stats(self, revid=None, committers=None):
1195
904
        """See Repository.gather_stats()."""
1196
905
        path = self.bzrdir._path_for_remote_call(self._client)
1197
906
        # revid can be None to indicate no revisions, not just NULL_REVISION
1198
 
        if revid is None or _mod_revision.is_null(revid):
 
907
        if revid is None or revision.is_null(revid):
1199
908
            fmt_revid = ''
1200
909
        else:
1201
910
            fmt_revid = revid
1262
971
        pass
1263
972
 
1264
973
    def lock_read(self):
1265
 
        """Lock the repository for read operations.
1266
 
 
1267
 
        :return: A bzrlib.lock.LogicalLockResult.
1268
 
        """
1269
974
        # wrong eventually - want a local lock cache context
1270
975
        if not self._lock_mode:
1271
976
            self._note_lock('r')
1278
983
                repo.lock_read()
1279
984
        else:
1280
985
            self._lock_count += 1
1281
 
        return lock.LogicalLockResult(self.unlock)
1282
986
 
1283
987
    def _remote_lock_write(self, token):
1284
988
        path = self.bzrdir._path_for_remote_call(self._client)
1324
1028
            raise errors.ReadOnlyError(self)
1325
1029
        else:
1326
1030
            self._lock_count += 1
1327
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1031
        return self._lock_token or None
1328
1032
 
1329
1033
    def leave_lock_in_place(self):
1330
1034
        if not self._lock_token:
1484
1188
 
1485
1189
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1486
1190
                           timezone=None, committer=None, revprops=None,
1487
 
                           revision_id=None, lossy=False):
 
1191
                           revision_id=None):
1488
1192
        # FIXME: It ought to be possible to call this without immediately
1489
1193
        # triggering _ensure_real.  For now it's the easiest thing to do.
1490
1194
        self._ensure_real()
1491
1195
        real_repo = self._real_repository
1492
1196
        builder = real_repo.get_commit_builder(branch, parents,
1493
1197
                config, timestamp=timestamp, timezone=timezone,
1494
 
                committer=committer, revprops=revprops,
1495
 
                revision_id=revision_id, lossy=lossy)
 
1198
                committer=committer, revprops=revprops, revision_id=revision_id)
1496
1199
        return builder
1497
1200
 
1498
1201
    def add_fallback_repository(self, repository):
1511
1214
            # state, so always add a lock here. If a caller passes us a locked
1512
1215
            # repository, they are responsible for unlocking it later.
1513
1216
            repository.lock_read()
1514
 
        self._check_fallback_repository(repository)
1515
1217
        self._fallback_repositories.append(repository)
1516
1218
        # If self._real_repository was parameterised already (e.g. because a
1517
1219
        # _real_branch had its get_stacked_on_url method called), then the
1518
1220
        # repository to be added may already be in the _real_repositories list.
1519
1221
        if self._real_repository is not None:
1520
 
            fallback_locations = [repo.user_url for repo in
 
1222
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1521
1223
                self._real_repository._fallback_repositories]
1522
 
            if repository.user_url not in fallback_locations:
 
1224
            if repository.bzrdir.root_transport.base not in fallback_locations:
1523
1225
                self._real_repository.add_fallback_repository(repository)
1524
1226
 
1525
 
    def _check_fallback_repository(self, repository):
1526
 
        """Check that this repository can fallback to repository safely.
1527
 
 
1528
 
        Raise an error if not.
1529
 
 
1530
 
        :param repository: A repository to fallback to.
1531
 
        """
1532
 
        return _mod_repository.InterRepository._assert_same_model(
1533
 
            self, repository)
1534
 
 
1535
1227
    def add_inventory(self, revid, inv, parents):
1536
1228
        self._ensure_real()
1537
1229
        return self._real_repository.add_inventory(revid, inv, parents)
1538
1230
 
1539
1231
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1540
 
            parents, basis_inv=None, propagate_caches=False):
 
1232
                               parents):
1541
1233
        self._ensure_real()
1542
1234
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1543
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1544
 
            propagate_caches=propagate_caches)
 
1235
            delta, new_revision_id, parents)
1545
1236
 
1546
1237
    def add_revision(self, rev_id, rev, inv=None, config=None):
1547
1238
        self._ensure_real()
1577
1268
        return self._real_repository.make_working_trees()
1578
1269
 
1579
1270
    def refresh_data(self):
1580
 
        """Re-read any data needed to synchronise with disk.
 
1271
        """Re-read any data needed to to synchronise with disk.
1581
1272
 
1582
1273
        This method is intended to be called after another repository instance
1583
1274
        (such as one used by a smart server) has inserted data into the
1584
 
        repository. On all repositories this will work outside of write groups.
1585
 
        Some repository formats (pack and newer for bzrlib native formats)
1586
 
        support refresh_data inside write groups. If called inside a write
1587
 
        group on a repository that does not support refreshing in a write group
1588
 
        IsInWriteGroupError will be raised.
 
1275
        repository. It may not be called during a write group, but may be
 
1276
        called at any other time.
1589
1277
        """
 
1278
        if self.is_in_write_group():
 
1279
            raise errors.InternalBzrError(
 
1280
                "May not refresh_data while in a write group.")
1590
1281
        if self._real_repository is not None:
1591
1282
            self._real_repository.refresh_data()
1592
1283
 
1604
1295
        return result
1605
1296
 
1606
1297
    @needs_read_lock
1607
 
    def search_missing_revision_ids(self, other,
1608
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1609
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1610
 
            limit=None):
 
1298
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1611
1299
        """Return the revision ids that other has that this does not.
1612
1300
 
1613
1301
        These are returned in topological order.
1614
1302
 
1615
1303
        revision_id: only return revision ids included by revision_id.
1616
1304
        """
1617
 
        if symbol_versioning.deprecated_passed(revision_id):
1618
 
            symbol_versioning.warn(
1619
 
                'search_missing_revision_ids(revision_id=...) was '
1620
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
1621
 
                DeprecationWarning, stacklevel=2)
1622
 
            if revision_ids is not None:
1623
 
                raise AssertionError(
1624
 
                    'revision_ids is mutually exclusive with revision_id')
1625
 
            if revision_id is not None:
1626
 
                revision_ids = [revision_id]
1627
 
        inter_repo = _mod_repository.InterRepository.get(other, self)
1628
 
        return inter_repo.search_missing_revision_ids(
1629
 
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1630
 
            if_present_ids=if_present_ids, limit=limit)
 
1305
        return repository.InterRepository.get(
 
1306
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
1631
1307
 
1632
 
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
1308
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1633
1309
            fetch_spec=None):
1634
1310
        # No base implementation to use as RemoteRepository is not a subclass
1635
1311
        # of Repository; so this is a copy of Repository.fetch().
1646
1322
            # check that last_revision is in 'from' and then return a
1647
1323
            # no-operation.
1648
1324
            if (revision_id is not None and
1649
 
                not _mod_revision.is_null(revision_id)):
 
1325
                not revision.is_null(revision_id)):
1650
1326
                self.get_revision(revision_id)
1651
1327
            return 0, []
1652
1328
        # if there is no specific appropriate InterRepository, this will get
1653
1329
        # the InterRepository base class, which raises an
1654
1330
        # IncompatibleRepositories when asked to fetch.
1655
 
        inter = _mod_repository.InterRepository.get(source, self)
1656
 
        return inter.fetch(revision_id=revision_id,
 
1331
        inter = repository.InterRepository.get(source, self)
 
1332
        return inter.fetch(revision_id=revision_id, pb=pb,
1657
1333
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1658
1334
 
1659
1335
    def create_bundle(self, target, base, fileobj, format=None):
1661
1337
        self._real_repository.create_bundle(target, base, fileobj, format)
1662
1338
 
1663
1339
    @needs_read_lock
1664
 
    @symbol_versioning.deprecated_method(
1665
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1666
1340
    def get_ancestry(self, revision_id, topo_sorted=True):
1667
1341
        self._ensure_real()
1668
1342
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1827
1501
        self._ensure_real()
1828
1502
        return self._real_repository._get_inventory_xml(revision_id)
1829
1503
 
 
1504
    def _deserialise_inventory(self, revision_id, xml):
 
1505
        self._ensure_real()
 
1506
        return self._real_repository._deserialise_inventory(revision_id, xml)
 
1507
 
1830
1508
    def reconcile(self, other=None, thorough=False):
1831
1509
        self._ensure_real()
1832
1510
        return self._real_repository.reconcile(other=other, thorough=thorough)
1885
1563
            tmpdir = osutils.mkdtemp()
1886
1564
            try:
1887
1565
                _extract_tar(tar, tmpdir)
1888
 
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
 
1566
                tmp_bzrdir = BzrDir.open(tmpdir)
1889
1567
                tmp_repo = tmp_bzrdir.open_repository()
1890
1568
                tmp_repo.copy_content_into(destination, revision_id)
1891
1569
            finally:
1907
1585
        return self._real_repository.inventories
1908
1586
 
1909
1587
    @needs_write_lock
1910
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1588
    def pack(self, hint=None):
1911
1589
        """Compress the data within the repository.
1912
1590
 
1913
1591
        This is not currently implemented within the smart server.
1914
1592
        """
1915
1593
        self._ensure_real()
1916
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1594
        return self._real_repository.pack(hint=hint)
1917
1595
 
1918
1596
    @property
1919
1597
    def revisions(self):
1976
1654
    def supports_rich_root(self):
1977
1655
        return self._format.rich_root_data
1978
1656
 
1979
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1980
1657
    def iter_reverse_revision_history(self, revision_id):
1981
1658
        self._ensure_real()
1982
1659
        return self._real_repository.iter_reverse_revision_history(revision_id)
2003
1680
        return self._real_repository.item_keys_introduced_by(revision_ids,
2004
1681
            _files_pb=_files_pb)
2005
1682
 
 
1683
    def revision_graph_can_have_wrong_parents(self):
 
1684
        # The answer depends on the remote repo format.
 
1685
        self._ensure_real()
 
1686
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
1687
 
2006
1688
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
2007
1689
        self._ensure_real()
2008
1690
        return self._real_repository._find_inconsistent_revision_parents(
2016
1698
        providers = [self._unstacked_provider]
2017
1699
        if other is not None:
2018
1700
            providers.insert(0, other)
2019
 
        return graph.StackedParentsProvider(_LazyListJoin(
2020
 
            providers, self._fallback_repositories))
 
1701
        providers.extend(r._make_parents_provider() for r in
 
1702
                         self._fallback_repositories)
 
1703
        return graph.StackedParentsProvider(providers)
2021
1704
 
2022
1705
    def _serialise_search_recipe(self, recipe):
2023
1706
        """Serialise a graph search recipe.
2031
1714
        return '\n'.join((start_keys, stop_keys, count))
2032
1715
 
2033
1716
    def _serialise_search_result(self, search_result):
2034
 
        parts = search_result.get_network_struct()
 
1717
        if isinstance(search_result, graph.PendingAncestryResult):
 
1718
            parts = ['ancestry-of']
 
1719
            parts.extend(search_result.heads)
 
1720
        else:
 
1721
            recipe = search_result.get_recipe()
 
1722
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
2035
1723
        return '\n'.join(parts)
2036
1724
 
2037
1725
    def autopack(self):
2047
1735
            raise errors.UnexpectedSmartServerResponse(response)
2048
1736
 
2049
1737
 
2050
 
class RemoteStreamSink(vf_repository.StreamSink):
 
1738
class RemoteStreamSink(repository.StreamSink):
2051
1739
 
2052
1740
    def _insert_real(self, stream, src_format, resume_tokens):
2053
1741
        self.target_repo._ensure_real()
2154
1842
        self._last_substream and self._last_stream so that the stream can be
2155
1843
        resumed by _resume_stream_with_vfs.
2156
1844
        """
2157
 
 
 
1845
                    
2158
1846
        stream_iter = iter(stream)
2159
1847
        for substream_kind, substream in stream_iter:
2160
1848
            if substream_kind == 'inventory-deltas':
2163
1851
                return
2164
1852
            else:
2165
1853
                yield substream_kind, substream
2166
 
 
2167
 
 
2168
 
class RemoteStreamSource(vf_repository.StreamSource):
 
1854
            
 
1855
 
 
1856
class RemoteStreamSource(repository.StreamSource):
2169
1857
    """Stream data from a remote server."""
2170
1858
 
2171
1859
    def get_stream(self, search):
2231
1919
        candidate_verbs = [
2232
1920
            ('Repository.get_stream_1.19', (1, 19)),
2233
1921
            ('Repository.get_stream', (1, 13))]
2234
 
 
2235
1922
        found_verb = False
2236
1923
        for verb, version in candidate_verbs:
2237
1924
            if medium._is_remote_before(version):
2241
1928
                    verb, args, search_bytes)
2242
1929
            except errors.UnknownSmartMethod:
2243
1930
                medium._remember_remote_is_before(version)
2244
 
            except errors.UnknownErrorFromSmartServer, e:
2245
 
                if isinstance(search, graph.EverythingResult):
2246
 
                    error_verb = e.error_from_smart_server.error_verb
2247
 
                    if error_verb == 'BadSearch':
2248
 
                        # Pre-2.4 servers don't support this sort of search.
2249
 
                        # XXX: perhaps falling back to VFS on BadSearch is a
2250
 
                        # good idea in general?  It might provide a little bit
2251
 
                        # of protection against client-side bugs.
2252
 
                        medium._remember_remote_is_before((2, 4))
2253
 
                        break
2254
 
                raise
2255
1931
            else:
2256
1932
                response_tuple, response_handler = response
2257
1933
                found_verb = True
2261
1937
        if response_tuple[0] != 'ok':
2262
1938
            raise errors.UnexpectedSmartServerResponse(response_tuple)
2263
1939
        byte_stream = response_handler.read_streamed_body()
2264
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
2265
 
            self._record_counter)
 
1940
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
2266
1941
        if src_format.network_name() != repo._format.network_name():
2267
1942
            raise AssertionError(
2268
1943
                "Mismatched RemoteRepository and stream src %r, %r" % (
2350
2025
    def network_name(self):
2351
2026
        return self._network_name
2352
2027
 
2353
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2354
 
        return a_bzrdir.open_branch(name=name, 
2355
 
            ignore_fallbacks=ignore_fallbacks)
 
2028
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
2029
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2356
2030
 
2357
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2031
    def _vfs_initialize(self, a_bzrdir):
2358
2032
        # Initialisation when using a local bzrdir object, or a non-vfs init
2359
2033
        # method is not available on the server.
2360
2034
        # self._custom_format is always set - the start of initialize ensures
2361
2035
        # that.
2362
2036
        if isinstance(a_bzrdir, RemoteBzrDir):
2363
2037
            a_bzrdir._ensure_real()
2364
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2365
 
                name)
 
2038
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2366
2039
        else:
2367
2040
            # We assume the bzrdir is parameterised; it may not be.
2368
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2041
            result = self._custom_format.initialize(a_bzrdir)
2369
2042
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2370
2043
            not isinstance(result, RemoteBranch)):
2371
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2372
 
                                  name=name)
 
2044
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2373
2045
        return result
2374
2046
 
2375
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
2047
    def initialize(self, a_bzrdir):
2376
2048
        # 1) get the network name to use.
2377
2049
        if self._custom_format:
2378
2050
            network_name = self._custom_format.network_name()
2379
2051
        else:
2380
2052
            # Select the current bzrlib default and ask for that.
2381
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
2053
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
2382
2054
            reference_format = reference_bzrdir_format.get_branch_format()
2383
2055
            self._custom_format = reference_format
2384
2056
            network_name = reference_format.network_name()
2385
2057
        # Being asked to create on a non RemoteBzrDir:
2386
2058
        if not isinstance(a_bzrdir, RemoteBzrDir):
2387
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2059
            return self._vfs_initialize(a_bzrdir)
2388
2060
        medium = a_bzrdir._client._medium
2389
2061
        if medium._is_remote_before((1, 13)):
2390
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2062
            return self._vfs_initialize(a_bzrdir)
2391
2063
        # Creating on a remote bzr dir.
2392
2064
        # 2) try direct creation via RPC
2393
2065
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2394
 
        if name is not None:
2395
 
            # XXX JRV20100304: Support creating colocated branches
2396
 
            raise errors.NoColocatedBranchSupport(self)
2397
2066
        verb = 'BzrDir.create_branch'
2398
2067
        try:
2399
2068
            response = a_bzrdir._call(verb, path, network_name)
2400
2069
        except errors.UnknownSmartMethod:
2401
2070
            # Fallback - use vfs methods
2402
2071
            medium._remember_remote_is_before((1, 13))
2403
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2072
            return self._vfs_initialize(a_bzrdir)
2404
2073
        if response[0] != 'ok':
2405
2074
            raise errors.UnexpectedSmartServerResponse(response)
2406
2075
        # Turn the response into a RemoteRepository object.
2407
2076
        format = RemoteBranchFormat(network_name=response[1])
2408
2077
        repo_format = response_tuple_to_repo_format(response[3:])
2409
 
        repo_path = response[2]
2410
 
        if repository is not None:
2411
 
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
2412
 
            url_diff = urlutils.relative_url(repository.user_url,
2413
 
                    remote_repo_url)
2414
 
            if url_diff != '.':
2415
 
                raise AssertionError(
2416
 
                    'repository.user_url %r does not match URL from server '
2417
 
                    'response (%r + %r)'
2418
 
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
2419
 
            remote_repo = repository
 
2078
        if response[2] == '':
 
2079
            repo_bzrdir = a_bzrdir
2420
2080
        else:
2421
 
            if repo_path == '':
2422
 
                repo_bzrdir = a_bzrdir
2423
 
            else:
2424
 
                repo_bzrdir = RemoteBzrDir(
2425
 
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
2426
 
                    a_bzrdir._client)
2427
 
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2081
            repo_bzrdir = RemoteBzrDir(
 
2082
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
 
2083
                a_bzrdir._client)
 
2084
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2428
2085
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2429
 
            format=format, setup_stacking=False, name=name)
 
2086
            format=format, setup_stacking=False)
2430
2087
        # XXX: We know this is a new branch, so it must have revno 0, revid
2431
2088
        # NULL_REVISION. Creating the branch locked would make this be unable
2432
2089
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2451
2108
        self._ensure_real()
2452
2109
        return self._custom_format.supports_set_append_revisions_only()
2453
2110
 
2454
 
    def _use_default_local_heads_to_fetch(self):
2455
 
        # If the branch format is a metadir format *and* its heads_to_fetch
2456
 
        # implementation is not overridden vs the base class, we can use the
2457
 
        # base class logic rather than use the heads_to_fetch RPC.  This is
2458
 
        # usually cheaper in terms of net round trips, as the last-revision and
2459
 
        # tags info fetched is cached and would be fetched anyway.
2460
 
        self._ensure_real()
2461
 
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
2462
 
            branch_class = self._custom_format._branch_class()
2463
 
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
2464
 
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
2465
 
                return True
2466
 
        return False
2467
2111
 
2468
2112
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2469
2113
    """Branch stored on a server accessed by HPSS RPC.
2472
2116
    """
2473
2117
 
2474
2118
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2475
 
        _client=None, format=None, setup_stacking=True, name=None):
 
2119
        _client=None, format=None, setup_stacking=True):
2476
2120
        """Create a RemoteBranch instance.
2477
2121
 
2478
2122
        :param real_branch: An optional local implementation of the branch
2484
2128
        :param setup_stacking: If True make an RPC call to determine the
2485
2129
            stacked (or not) status of the branch. If False assume the branch
2486
2130
            is not stacked.
2487
 
        :param name: Colocated branch name
2488
2131
        """
2489
2132
        # We intentionally don't call the parent class's __init__, because it
2490
2133
        # will try to assign to self.tags, which is a property in this subclass.
2509
2152
            self._real_branch = None
2510
2153
        # Fill out expected attributes of branch for bzrlib API users.
2511
2154
        self._clear_cached_state()
2512
 
        # TODO: deprecate self.base in favor of user_url
2513
 
        self.base = self.bzrdir.user_url
2514
 
        self._name = name
 
2155
        self.base = self.bzrdir.root_transport.base
2515
2156
        self._control_files = None
2516
2157
        self._lock_mode = None
2517
2158
        self._lock_token = None
2582
2223
                    'to use vfs implementation')
2583
2224
            self.bzrdir._ensure_real()
2584
2225
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2585
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
2226
                ignore_fallbacks=self._real_ignore_fallbacks)
2586
2227
            if self.repository._real_repository is None:
2587
2228
                # Give the remote repository the matching real repo.
2588
2229
                real_repo = self._real_branch.repository
2668
2309
            self._is_stacked = False
2669
2310
        else:
2670
2311
            self._is_stacked = True
2671
 
 
 
2312
        
2672
2313
    def _vfs_get_tags_bytes(self):
2673
2314
        self._ensure_real()
2674
2315
        return self._real_branch._get_tags_bytes()
2675
2316
 
2676
 
    @needs_read_lock
2677
2317
    def _get_tags_bytes(self):
2678
 
        if self._tags_bytes is None:
2679
 
            self._tags_bytes = self._get_tags_bytes_via_hpss()
2680
 
        return self._tags_bytes
2681
 
 
2682
 
    def _get_tags_bytes_via_hpss(self):
2683
2318
        medium = self._client._medium
2684
2319
        if medium._is_remote_before((1, 13)):
2685
2320
            return self._vfs_get_tags_bytes()
2695
2330
        return self._real_branch._set_tags_bytes(bytes)
2696
2331
 
2697
2332
    def _set_tags_bytes(self, bytes):
2698
 
        if self.is_locked():
2699
 
            self._tags_bytes = bytes
2700
2333
        medium = self._client._medium
2701
2334
        if medium._is_remote_before((1, 18)):
2702
2335
            self._vfs_set_tags_bytes(bytes)
2711
2344
            self._vfs_set_tags_bytes(bytes)
2712
2345
 
2713
2346
    def lock_read(self):
2714
 
        """Lock the branch for read operations.
2715
 
 
2716
 
        :return: A bzrlib.lock.LogicalLockResult.
2717
 
        """
2718
2347
        self.repository.lock_read()
2719
2348
        if not self._lock_mode:
2720
2349
            self._note_lock('r')
2724
2353
                self._real_branch.lock_read()
2725
2354
        else:
2726
2355
            self._lock_count += 1
2727
 
        return lock.LogicalLockResult(self.unlock)
2728
2356
 
2729
2357
    def _remote_lock_write(self, token):
2730
2358
        if token is None:
2731
2359
            branch_token = repo_token = ''
2732
2360
        else:
2733
2361
            branch_token = token
2734
 
            repo_token = self.repository.lock_write().repository_token
 
2362
            repo_token = self.repository.lock_write()
2735
2363
            self.repository.unlock()
2736
2364
        err_context = {'token': token}
2737
 
        try:
2738
 
            response = self._call(
2739
 
                'Branch.lock_write', self._remote_path(), branch_token,
2740
 
                repo_token or '', **err_context)
2741
 
        except errors.LockContention, e:
2742
 
            # The LockContention from the server doesn't have any
2743
 
            # information about the lock_url. We re-raise LockContention
2744
 
            # with valid lock_url.
2745
 
            raise errors.LockContention('(remote lock)',
2746
 
                self.repository.base.split('.bzr/')[0])
 
2365
        response = self._call(
 
2366
            'Branch.lock_write', self._remote_path(), branch_token,
 
2367
            repo_token or '', **err_context)
2747
2368
        if response[0] != 'ok':
2748
2369
            raise errors.UnexpectedSmartServerResponse(response)
2749
2370
        ok, branch_token, repo_token = response
2770
2391
            self._lock_mode = 'w'
2771
2392
            self._lock_count = 1
2772
2393
        elif self._lock_mode == 'r':
2773
 
            raise errors.ReadOnlyError(self)
 
2394
            raise errors.ReadOnlyTransaction
2774
2395
        else:
2775
2396
            if token is not None:
2776
2397
                # A token was given to lock_write, and we're relocking, so
2781
2402
            self._lock_count += 1
2782
2403
            # Re-lock the repository too.
2783
2404
            self.repository.lock_write(self._repo_lock_token)
2784
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2405
        return self._lock_token or None
2785
2406
 
2786
2407
    def _unlock(self, branch_token, repo_token):
2787
2408
        err_context = {'token': str((branch_token, repo_token))}
2856
2477
            missing_parent = parent_map[missing_parent]
2857
2478
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2858
2479
 
2859
 
    def _read_last_revision_info(self):
 
2480
    def _last_revision_info(self):
2860
2481
        response = self._call('Branch.last_revision_info', self._remote_path())
2861
2482
        if response[0] != 'ok':
2862
2483
            raise SmartProtocolError('unexpected response code %s' % (response,))
2925
2546
            raise errors.UnexpectedSmartServerResponse(response)
2926
2547
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2927
2548
 
2928
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2929
2549
    @needs_write_lock
2930
2550
    def set_revision_history(self, rev_history):
2931
 
        """See Branch.set_revision_history."""
2932
 
        self._set_revision_history(rev_history)
2933
 
 
2934
 
    @needs_write_lock
2935
 
    def _set_revision_history(self, rev_history):
2936
2551
        # Send just the tip revision of the history; the server will generate
2937
2552
        # the full history from that.  If the revision doesn't exist in this
2938
2553
        # branch, NoSuchRevision will be raised.
2996
2611
            _override_hook_target=self, **kwargs)
2997
2612
 
2998
2613
    @needs_read_lock
2999
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
 
2614
    def push(self, target, overwrite=False, stop_revision=None):
3000
2615
        self._ensure_real()
3001
2616
        return self._real_branch.push(
3002
 
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
 
2617
            target, overwrite=overwrite, stop_revision=stop_revision,
3003
2618
            _override_hook_source_branch=self)
3004
2619
 
3005
2620
    def is_locked(self):
3015
2630
        # XXX: These should be returned by the set_last_revision_info verb
3016
2631
        old_revno, old_revid = self.last_revision_info()
3017
2632
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
3018
 
        if not revision_id or not isinstance(revision_id, basestring):
3019
 
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2633
        revision_id = ensure_null(revision_id)
3020
2634
        try:
3021
2635
            response = self._call('Branch.set_last_revision_info',
3022
2636
                self._remote_path(), self._lock_token, self._repo_lock_token,
3051
2665
            except errors.UnknownSmartMethod:
3052
2666
                medium._remember_remote_is_before((1, 6))
3053
2667
        self._clear_cached_state_of_remote_branch_only()
3054
 
        self._set_revision_history(self._lefthand_history(revision_id,
 
2668
        self.set_revision_history(self._lefthand_history(revision_id,
3055
2669
            last_rev=last_rev,other_branch=other_branch))
3056
2670
 
3057
2671
    def set_push_location(self, location):
3058
2672
        self._ensure_real()
3059
2673
        return self._real_branch.set_push_location(location)
3060
2674
 
3061
 
    def heads_to_fetch(self):
3062
 
        if self._format._use_default_local_heads_to_fetch():
3063
 
            # We recognise this format, and its heads-to-fetch implementation
3064
 
            # is the default one (tip + tags).  In this case it's cheaper to
3065
 
            # just use the default implementation rather than a special RPC as
3066
 
            # the tip and tags data is cached.
3067
 
            return branch.Branch.heads_to_fetch(self)
3068
 
        medium = self._client._medium
3069
 
        if medium._is_remote_before((2, 4)):
3070
 
            return self._vfs_heads_to_fetch()
3071
 
        try:
3072
 
            return self._rpc_heads_to_fetch()
3073
 
        except errors.UnknownSmartMethod:
3074
 
            medium._remember_remote_is_before((2, 4))
3075
 
            return self._vfs_heads_to_fetch()
3076
 
 
3077
 
    def _rpc_heads_to_fetch(self):
3078
 
        response = self._call('Branch.heads_to_fetch', self._remote_path())
3079
 
        if len(response) != 2:
3080
 
            raise errors.UnexpectedSmartServerResponse(response)
3081
 
        must_fetch, if_present_fetch = response
3082
 
        return set(must_fetch), set(if_present_fetch)
3083
 
 
3084
 
    def _vfs_heads_to_fetch(self):
3085
 
        self._ensure_real()
3086
 
        return self._real_branch.heads_to_fetch()
3087
 
 
3088
2675
 
3089
2676
class RemoteConfig(object):
3090
2677
    """A Config that reads and writes from smart verbs.
3104
2691
        """
3105
2692
        try:
3106
2693
            configobj = self._get_configobj()
3107
 
            section_obj = None
3108
2694
            if section is None:
3109
2695
                section_obj = configobj
3110
2696
            else:
3111
2697
                try:
3112
2698
                    section_obj = configobj[section]
3113
2699
                except KeyError:
3114
 
                    pass
3115
 
            if section_obj is None:
3116
 
                value = default
3117
 
            else:
3118
 
                value = section_obj.get(name, default)
 
2700
                    return default
 
2701
            return section_obj.get(name, default)
3119
2702
        except errors.UnknownSmartMethod:
3120
 
            value = self._vfs_get_option(name, section, default)
3121
 
        for hook in config.OldConfigHooks['get']:
3122
 
            hook(self, name, value)
3123
 
        return value
 
2703
            return self._vfs_get_option(name, section, default)
3124
2704
 
3125
2705
    def _response_to_configobj(self, response):
3126
2706
        if len(response[0]) and response[0][0] != 'ok':
3127
2707
            raise errors.UnexpectedSmartServerResponse(response)
3128
2708
        lines = response[1].read_body_bytes().splitlines()
3129
 
        conf = config.ConfigObj(lines, encoding='utf-8')
3130
 
        for hook in config.OldConfigHooks['load']:
3131
 
            hook(self)
3132
 
        return conf
 
2709
        return config.ConfigObj(lines, encoding='utf-8')
3133
2710
 
3134
2711
 
3135
2712
class RemoteBranchConfig(RemoteConfig):
3154
2731
        medium = self._branch._client._medium
3155
2732
        if medium._is_remote_before((1, 14)):
3156
2733
            return self._vfs_set_option(value, name, section)
3157
 
        if isinstance(value, dict):
3158
 
            if medium._is_remote_before((2, 2)):
3159
 
                return self._vfs_set_option(value, name, section)
3160
 
            return self._set_config_option_dict(value, name, section)
3161
 
        else:
3162
 
            return self._set_config_option(value, name, section)
3163
 
 
3164
 
    def _set_config_option(self, value, name, section):
3165
2734
        try:
3166
2735
            path = self._branch._remote_path()
3167
2736
            response = self._branch._client.call('Branch.set_config_option',
3168
2737
                path, self._branch._lock_token, self._branch._repo_lock_token,
3169
2738
                value.encode('utf8'), name, section or '')
3170
2739
        except errors.UnknownSmartMethod:
3171
 
            medium = self._branch._client._medium
3172
2740
            medium._remember_remote_is_before((1, 14))
3173
2741
            return self._vfs_set_option(value, name, section)
3174
2742
        if response != ():
3175
2743
            raise errors.UnexpectedSmartServerResponse(response)
3176
2744
 
3177
 
    def _serialize_option_dict(self, option_dict):
3178
 
        utf8_dict = {}
3179
 
        for key, value in option_dict.items():
3180
 
            if isinstance(key, unicode):
3181
 
                key = key.encode('utf8')
3182
 
            if isinstance(value, unicode):
3183
 
                value = value.encode('utf8')
3184
 
            utf8_dict[key] = value
3185
 
        return bencode.bencode(utf8_dict)
3186
 
 
3187
 
    def _set_config_option_dict(self, value, name, section):
3188
 
        try:
3189
 
            path = self._branch._remote_path()
3190
 
            serialised_dict = self._serialize_option_dict(value)
3191
 
            response = self._branch._client.call(
3192
 
                'Branch.set_config_option_dict',
3193
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
3194
 
                serialised_dict, name, section or '')
3195
 
        except errors.UnknownSmartMethod:
3196
 
            medium = self._branch._client._medium
3197
 
            medium._remember_remote_is_before((2, 2))
3198
 
            return self._vfs_set_option(value, name, section)
3199
 
        if response != ():
3200
 
            raise errors.UnexpectedSmartServerResponse(response)
3201
 
 
3202
2745
    def _real_object(self):
3203
2746
        self._branch._ensure_real()
3204
2747
        return self._branch._real_branch
3287
2830
                    'Missing key %r in context %r', key_err.args[0], context)
3288
2831
                raise err
3289
2832
 
3290
 
    if err.error_verb == 'NoSuchRevision':
 
2833
    if err.error_verb == 'IncompatibleRepositories':
 
2834
        raise errors.IncompatibleRepositories(err.error_args[0],
 
2835
            err.error_args[1], err.error_args[2])
 
2836
    elif err.error_verb == 'NoSuchRevision':
3291
2837
        raise NoSuchRevision(find('branch'), err.error_args[0])
3292
2838
    elif err.error_verb == 'nosuchrevision':
3293
2839
        raise NoSuchRevision(find('repository'), err.error_args[0])
3300
2846
            detail=extra)
3301
2847
    elif err.error_verb == 'norepository':
3302
2848
        raise errors.NoRepositoryPresent(find('bzrdir'))
 
2849
    elif err.error_verb == 'LockContention':
 
2850
        raise errors.LockContention('(remote lock)')
3303
2851
    elif err.error_verb == 'UnlockableTransport':
3304
2852
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
 
2853
    elif err.error_verb == 'LockFailed':
 
2854
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3305
2855
    elif err.error_verb == 'TokenMismatch':
3306
2856
        raise errors.TokenMismatch(find('token'), '(remote token)')
3307
2857
    elif err.error_verb == 'Diverged':
3308
2858
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
 
2859
    elif err.error_verb == 'TipChangeRejected':
 
2860
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
2861
    elif err.error_verb == 'UnstackableBranchFormat':
 
2862
        raise errors.UnstackableBranchFormat(*err.error_args)
 
2863
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
2864
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3309
2865
    elif err.error_verb == 'NotStacked':
3310
2866
        raise errors.NotStacked(branch=find('branch'))
3311
2867
    elif err.error_verb == 'PermissionDenied':
3321
2877
    elif err.error_verb == 'NoSuchFile':
3322
2878
        path = get_path()
3323
2879
        raise errors.NoSuchFile(path)
3324
 
    _translate_error_without_context(err)
3325
 
 
3326
 
 
3327
 
def _translate_error_without_context(err):
3328
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3329
 
    if err.error_verb == 'IncompatibleRepositories':
3330
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3331
 
            err.error_args[1], err.error_args[2])
3332
 
    elif err.error_verb == 'LockContention':
3333
 
        raise errors.LockContention('(remote lock)')
3334
 
    elif err.error_verb == 'LockFailed':
3335
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3336
 
    elif err.error_verb == 'TipChangeRejected':
3337
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3338
 
    elif err.error_verb == 'UnstackableBranchFormat':
3339
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3340
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3341
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3342
2880
    elif err.error_verb == 'FileExists':
3343
2881
        raise errors.FileExists(err.error_args[0])
3344
2882
    elif err.error_verb == 'DirectoryNotEmpty':
3363
2901
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3364
2902
    elif err.error_verb == 'ReadOnlyError':
3365
2903
        raise errors.TransportNotPossible('readonly transport')
3366
 
    elif err.error_verb == 'MemoryError':
3367
 
        raise errors.BzrError("remote server out of memory\n"
3368
 
            "Retry non-remotely, or contact the server admin for details.")
3369
2904
    raise errors.UnknownErrorFromSmartServer(err)