← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Johan Walles
  • Date: 2009-05-07 05:08:46 UTC
  • mfrom: (4342 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4343.
  • Revision ID: johan.walles@gmail.com-20090507050846-nkwvcyauf1eh653q
Merge from upstream.

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, 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 (
20
 
    bencode,
21
23
    branch,
22
 
    bzrdir as _mod_bzrdir,
 
24
    bzrdir,
23
25
    config,
24
 
    controldir,
25
26
    debug,
26
27
    errors,
27
28
    graph,
28
 
    lock,
29
29
    lockdir,
30
 
    repository as _mod_repository,
 
30
    pack,
 
31
    repository,
 
32
    revision,
31
33
    revision as _mod_revision,
32
 
    static_tuple,
33
34
    symbol_versioning,
34
35
    urlutils,
35
 
    vf_repository,
36
 
    )
37
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
36
)
 
37
from bzrlib.branch import BranchReferenceFormat
 
38
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
39
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
40
from bzrlib.errors import (
40
41
    NoSuchRevision,
41
42
    SmartProtocolError,
42
43
    )
43
44
from bzrlib.lockable_files import LockableFiles
44
45
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
 
46
from bzrlib.revision import ensure_null, NULL_REVISION
48
47
from bzrlib.trace import mutter, note, warning
 
48
from bzrlib.util import bencode
49
49
 
50
50
 
51
51
class _RpcHelper(object):
63
63
        except errors.ErrorFromSmartServer, err:
64
64
            self._translate_error(err, **err_context)
65
65
 
66
 
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
67
 
        try:
68
 
            return self._client.call_with_body_bytes(method, args, body_bytes)
69
 
        except errors.ErrorFromSmartServer, err:
70
 
            self._translate_error(err, **err_context)
71
 
 
72
66
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
73
67
                                             **err_context):
74
68
        try:
88
82
    return format
89
83
 
90
84
 
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):
 
85
# Note: RemoteBzrDirFormat is in bzrdir.py
 
86
 
 
87
class RemoteBzrDir(BzrDir, _RpcHelper):
331
88
    """Control directory on a remote server, accessed via bzr:// or similar."""
332
89
 
333
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
90
    def __init__(self, transport, format, _client=None):
334
91
        """Construct a RemoteBzrDir.
335
92
 
336
93
        :param _client: Private parameter for testing. Disables probing and the
337
94
            use of a real bzrdir.
338
95
        """
339
 
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
 
96
        BzrDir.__init__(self, transport, format)
340
97
        # this object holds a delegated bzrdir that uses file-level operations
341
98
        # to talk to the other side
342
99
        self._real_bzrdir = None
343
 
        self._has_working_tree = None
344
100
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
345
101
        # create_branch for details.
346
102
        self._next_open_branch_result = None
350
106
            self._client = client._SmartClient(medium)
351
107
        else:
352
108
            self._client = _client
353
 
            if not _force_probe:
354
 
                return
355
 
 
356
 
        self._probe_bzrdir()
357
 
 
358
 
    def __repr__(self):
359
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
360
 
 
361
 
    def _probe_bzrdir(self):
362
 
        medium = self._client._medium
 
109
            return
 
110
 
363
111
        path = self._path_for_remote_call(self._client)
364
 
        if medium._is_remote_before((2, 1)):
365
 
            self._rpc_open(path)
366
 
            return
367
 
        try:
368
 
            self._rpc_open_2_1(path)
369
 
            return
370
 
        except errors.UnknownSmartMethod:
371
 
            medium._remember_remote_is_before((2, 1))
372
 
            self._rpc_open(path)
373
 
 
374
 
    def _rpc_open_2_1(self, path):
375
 
        response = self._call('BzrDir.open_2.1', path)
376
 
        if response == ('no',):
377
 
            raise errors.NotBranchError(path=self.root_transport.base)
378
 
        elif response[0] == 'yes':
379
 
            if response[1] == 'yes':
380
 
                self._has_working_tree = True
381
 
            elif response[1] == 'no':
382
 
                self._has_working_tree = False
383
 
            else:
384
 
                raise errors.UnexpectedSmartServerResponse(response)
385
 
        else:
386
 
            raise errors.UnexpectedSmartServerResponse(response)
387
 
 
388
 
    def _rpc_open(self, path):
389
112
        response = self._call('BzrDir.open', path)
390
113
        if response not in [('yes',), ('no',)]:
391
114
            raise errors.UnexpectedSmartServerResponse(response)
392
115
        if response == ('no',):
393
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
116
            raise errors.NotBranchError(path=transport.base)
394
117
 
395
118
    def _ensure_real(self):
396
119
        """Ensure that there is a _real_bzrdir set.
398
121
        Used before calls to self._real_bzrdir.
399
122
        """
400
123
        if not self._real_bzrdir:
401
 
            if 'hpssvfs' in debug.debug_flags:
402
 
                import traceback
403
 
                warning('VFS BzrDir access triggered\n%s',
404
 
                    ''.join(traceback.format_stack()))
405
 
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
124
            self._real_bzrdir = BzrDir.open_from_transport(
406
125
                self.root_transport, _server_formats=False)
407
126
            self._format._network_name = \
408
127
                self._real_bzrdir._format.network_name()
414
133
        # Prevent aliasing problems in the next_open_branch_result cache.
415
134
        # See create_branch for rationale.
416
135
        self._next_open_branch_result = None
417
 
        return _mod_bzrdir.BzrDir.break_lock(self)
 
136
        return BzrDir.break_lock(self)
418
137
 
419
138
    def _vfs_cloning_metadir(self, require_stacking=False):
420
139
        self._ensure_real()
451
170
        if len(branch_info) != 2:
452
171
            raise errors.UnexpectedSmartServerResponse(response)
453
172
        branch_ref, branch_name = branch_info
454
 
        format = controldir.network_format_registry.get(control_name)
 
173
        format = bzrdir.network_format_registry.get(control_name)
455
174
        if repo_name:
456
 
            format.repository_format = _mod_repository.network_format_registry.get(
 
175
            format.repository_format = repository.network_format_registry.get(
457
176
                repo_name)
458
177
        if branch_ref == 'ref':
459
178
            # XXX: we need possible_transports here to avoid reopening the
460
179
            # connection to the referenced location
461
 
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
 
180
            ref_bzrdir = BzrDir.open(branch_name)
462
181
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
463
182
            format.set_branch_format(branch_format)
464
183
        elif branch_ref == 'branch':
483
202
        self._ensure_real()
484
203
        self._real_bzrdir.destroy_repository()
485
204
 
486
 
    def create_branch(self, name=None, repository=None):
 
205
    def create_branch(self):
487
206
        # as per meta1 formats - just delegate to the format object which may
488
207
        # be parameterised.
489
 
        real_branch = self._format.get_branch_format().initialize(self,
490
 
            name=name, repository=repository)
 
208
        real_branch = self._format.get_branch_format().initialize(self)
491
209
        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)
 
210
            result = RemoteBranch(self, self.find_repository(), real_branch)
497
211
        else:
498
212
            result = real_branch
499
213
        # BzrDir.clone_on_transport() uses the result of create_branch but does
505
219
        self._next_open_branch_result = result
506
220
        return result
507
221
 
508
 
    def destroy_branch(self, name=None):
 
222
    def destroy_branch(self):
509
223
        """See BzrDir.destroy_branch"""
510
224
        self._ensure_real()
511
 
        self._real_bzrdir.destroy_branch(name=name)
 
225
        self._real_bzrdir.destroy_branch()
512
226
        self._next_open_branch_result = None
513
227
 
514
 
    def create_workingtree(self, revision_id=None, from_branch=None,
515
 
        accelerator_tree=None, hardlink=False):
 
228
    def create_workingtree(self, revision_id=None, from_branch=None):
516
229
        raise errors.NotLocalUrl(self.transport.base)
517
230
 
518
 
    def find_branch_format(self, name=None):
 
231
    def find_branch_format(self):
519
232
        """Find the branch 'format' for this bzrdir.
520
233
 
521
234
        This might be a synthetic object for e.g. RemoteBranch and SVN.
522
235
        """
523
 
        b = self.open_branch(name=name)
 
236
        b = self.open_branch()
524
237
        return b._format
525
238
 
526
 
    def get_branch_reference(self, name=None):
 
239
    def get_branch_reference(self):
527
240
        """See BzrDir.get_branch_reference()."""
528
 
        if name is not None:
529
 
            # XXX JRV20100304: Support opening colocated branches
530
 
            raise errors.NoColocatedBranchSupport(self)
531
241
        response = self._get_branch_reference()
532
242
        if response[0] == 'ref':
533
243
            return response[1]
537
247
    def _get_branch_reference(self):
538
248
        path = self._path_for_remote_call(self._client)
539
249
        medium = self._client._medium
540
 
        candidate_calls = [
541
 
            ('BzrDir.open_branchV3', (2, 1)),
542
 
            ('BzrDir.open_branchV2', (1, 13)),
543
 
            ('BzrDir.open_branch', None),
544
 
            ]
545
 
        for verb, required_version in candidate_calls:
546
 
            if required_version and medium._is_remote_before(required_version):
547
 
                continue
 
250
        if not medium._is_remote_before((1, 13)):
548
251
            try:
549
 
                response = self._call(verb, path)
 
252
                response = self._call('BzrDir.open_branchV2', path)
 
253
                if response[0] not in ('ref', 'branch'):
 
254
                    raise errors.UnexpectedSmartServerResponse(response)
 
255
                return response
550
256
            except errors.UnknownSmartMethod:
551
 
                if required_version is None:
552
 
                    raise
553
 
                medium._remember_remote_is_before(required_version)
554
 
            else:
555
 
                break
556
 
        if verb == 'BzrDir.open_branch':
557
 
            if response[0] != 'ok':
558
 
                raise errors.UnexpectedSmartServerResponse(response)
559
 
            if response[1] != '':
560
 
                return ('ref', response[1])
561
 
            else:
562
 
                return ('branch', '')
563
 
        if response[0] not in ('ref', 'branch'):
 
257
                medium._remember_remote_is_before((1, 13))
 
258
        response = self._call('BzrDir.open_branch', path)
 
259
        if response[0] != 'ok':
564
260
            raise errors.UnexpectedSmartServerResponse(response)
565
 
        return response
 
261
        if response[1] != '':
 
262
            return ('ref', response[1])
 
263
        else:
 
264
            return ('branch', '')
566
265
 
567
 
    def _get_tree_branch(self, name=None):
 
266
    def _get_tree_branch(self):
568
267
        """See BzrDir._get_tree_branch()."""
569
 
        return None, self.open_branch(name=name)
 
268
        return None, self.open_branch()
570
269
 
571
 
    def open_branch(self, name=None, unsupported=False,
572
 
                    ignore_fallbacks=False):
573
 
        if unsupported:
 
270
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
271
        if _unsupported:
574
272
            raise NotImplementedError('unsupported flag support not implemented yet.')
575
273
        if self._next_open_branch_result is not None:
576
274
            # See create_branch for details.
581
279
        if response[0] == 'ref':
582
280
            # a branch reference, use the existing BranchReference logic.
583
281
            format = BranchReferenceFormat()
584
 
            return format.open(self, name=name, _found=True,
585
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
282
            return format.open(self, _found=True, location=response[1],
 
283
                ignore_fallbacks=ignore_fallbacks)
586
284
        branch_format_name = response[1]
587
285
        if not branch_format_name:
588
286
            branch_format_name = None
589
287
        format = RemoteBranchFormat(network_name=branch_format_name)
590
288
        return RemoteBranch(self, self.find_repository(), format=format,
591
 
            setup_stacking=not ignore_fallbacks, name=name)
 
289
            setup_stacking=not ignore_fallbacks)
592
290
 
593
291
    def _open_repo_v1(self, path):
594
292
        verb = 'BzrDir.find_repository'
655
353
        else:
656
354
            raise errors.NoRepositoryPresent(self)
657
355
 
658
 
    def has_workingtree(self):
659
 
        if self._has_working_tree is None:
660
 
            self._ensure_real()
661
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
662
 
        return self._has_working_tree
663
 
 
664
356
    def open_workingtree(self, recommend_upgrade=True):
665
 
        if self.has_workingtree():
 
357
        self._ensure_real()
 
358
        if self._real_bzrdir.has_workingtree():
666
359
            raise errors.NotLocalUrl(self.root_transport)
667
360
        else:
668
361
            raise errors.NoWorkingTree(self.root_transport.base)
671
364
        """Return the path to be used for this bzrdir in a remote call."""
672
365
        return client.remote_path_from_transport(self.root_transport)
673
366
 
674
 
    def get_branch_transport(self, branch_format, name=None):
 
367
    def get_branch_transport(self, branch_format):
675
368
        self._ensure_real()
676
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
369
        return self._real_bzrdir.get_branch_transport(branch_format)
677
370
 
678
371
    def get_repository_transport(self, repository_format):
679
372
        self._ensure_real()
687
380
        """Upgrading of remote bzrdirs is not supported yet."""
688
381
        return False
689
382
 
690
 
    def needs_format_conversion(self, format):
 
383
    def needs_format_conversion(self, format=None):
691
384
        """Upgrading of remote bzrdirs is not supported yet."""
 
385
        if format is None:
 
386
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
387
                % 'needs_format_conversion(format=None)')
692
388
        return False
693
389
 
694
390
    def clone(self, url, revision_id=None, force_new_repo=False,
701
397
        return RemoteBzrDirConfig(self)
702
398
 
703
399
 
704
 
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
 
400
class RemoteRepositoryFormat(repository.RepositoryFormat):
705
401
    """Format for repositories accessed over a _SmartClient.
706
402
 
707
403
    Instances of this repository are represented by RemoteRepository
722
418
    """
723
419
 
724
420
    _matchingbzrdir = RemoteBzrDirFormat()
725
 
    supports_full_versioned_files = True
726
 
    supports_leaving_lock = True
727
421
 
728
422
    def __init__(self):
729
 
        _mod_repository.RepositoryFormat.__init__(self)
 
423
        repository.RepositoryFormat.__init__(self)
730
424
        self._custom_format = None
731
425
        self._network_name = None
732
426
        self._creating_bzrdir = None
733
 
        self._revision_graph_can_have_wrong_parents = None
734
 
        self._supports_chks = None
735
427
        self._supports_external_lookups = None
736
428
        self._supports_tree_reference = None
737
 
        self._supports_funky_characters = None
738
429
        self._rich_root_data = None
739
430
 
740
 
    def __repr__(self):
741
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
742
 
            self._network_name)
743
 
 
744
431
    @property
745
432
    def fast_deltas(self):
746
433
        self._ensure_real()
754
441
        return self._rich_root_data
755
442
 
756
443
    @property
757
 
    def supports_chks(self):
758
 
        if self._supports_chks is None:
759
 
            self._ensure_real()
760
 
            self._supports_chks = self._custom_format.supports_chks
761
 
        return self._supports_chks
762
 
 
763
 
    @property
764
444
    def supports_external_lookups(self):
765
445
        if self._supports_external_lookups is None:
766
446
            self._ensure_real()
769
449
        return self._supports_external_lookups
770
450
 
771
451
    @property
772
 
    def supports_funky_characters(self):
773
 
        if self._supports_funky_characters is None:
774
 
            self._ensure_real()
775
 
            self._supports_funky_characters = \
776
 
                self._custom_format.supports_funky_characters
777
 
        return self._supports_funky_characters
778
 
 
779
 
    @property
780
452
    def supports_tree_reference(self):
781
453
        if self._supports_tree_reference is None:
782
454
            self._ensure_real()
784
456
                self._custom_format.supports_tree_reference
785
457
        return self._supports_tree_reference
786
458
 
787
 
    @property
788
 
    def revision_graph_can_have_wrong_parents(self):
789
 
        if self._revision_graph_can_have_wrong_parents is None:
790
 
            self._ensure_real()
791
 
            self._revision_graph_can_have_wrong_parents = \
792
 
                self._custom_format.revision_graph_can_have_wrong_parents
793
 
        return self._revision_graph_can_have_wrong_parents
794
 
 
795
459
    def _vfs_initialize(self, a_bzrdir, shared):
796
460
        """Helper for common code in initialize."""
797
461
        if self._custom_format:
832
496
            network_name = self._network_name
833
497
        else:
834
498
            # Select the current bzrlib default and ask for that.
835
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
499
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
836
500
            reference_format = reference_bzrdir_format.repository_format
837
501
            network_name = reference_format.network_name()
838
502
        # 2) try direct creation via RPC
864
528
 
865
529
    def _ensure_real(self):
866
530
        if self._custom_format is None:
867
 
            self._custom_format = _mod_repository.network_format_registry.get(
 
531
            self._custom_format = repository.network_format_registry.get(
868
532
                self._network_name)
869
533
 
870
534
    @property
883
547
        return self._custom_format._fetch_reconcile
884
548
 
885
549
    def get_format_description(self):
886
 
        self._ensure_real()
887
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
550
        return 'bzr remote repository'
888
551
 
889
552
    def __eq__(self, other):
890
553
        return self.__class__ is other.__class__
891
554
 
 
555
    def check_conversion_target(self, target_format):
 
556
        if self.rich_root_data and not target_format.rich_root_data:
 
557
            raise errors.BadConversionTarget(
 
558
                'Does not support rich root data.', target_format)
 
559
        if (self.supports_tree_reference and
 
560
            not getattr(target_format, 'supports_tree_reference', False)):
 
561
            raise errors.BadConversionTarget(
 
562
                'Does not support nested trees', target_format)
 
563
 
892
564
    def network_name(self):
893
565
        if self._network_name:
894
566
            return self._network_name
896
568
        return self._creating_repo._real_repository._format.network_name()
897
569
 
898
570
    @property
899
 
    def pack_compresses(self):
900
 
        self._ensure_real()
901
 
        return self._custom_format.pack_compresses
902
 
 
903
 
    @property
904
571
    def _serializer(self):
905
572
        self._ensure_real()
906
573
        return self._custom_format._serializer
907
574
 
908
575
 
909
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
910
 
    controldir.ControlComponent):
 
576
class RemoteRepository(_RpcHelper):
911
577
    """Repository accessed over rpc.
912
578
 
913
579
    For the moment most operations are performed using local transport-backed
956
622
        # Additional places to query for data.
957
623
        self._fallback_repositories = []
958
624
 
959
 
    @property
960
 
    def user_transport(self):
961
 
        return self.bzrdir.user_transport
962
 
 
963
 
    @property
964
 
    def control_transport(self):
965
 
        # XXX: Normally you shouldn't directly get at the remote repository
966
 
        # transport, but I'm not sure it's worth making this method
967
 
        # optional -- mbp 2010-04-21
968
 
        return self.bzrdir.get_repository_transport(None)
969
 
 
970
625
    def __str__(self):
971
626
        return "%s(%s)" % (self.__class__.__name__, self.base)
972
627
 
1015
670
        self._ensure_real()
1016
671
        return self._real_repository.suspend_write_group()
1017
672
 
1018
 
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
1019
 
        self._ensure_real()
1020
 
        return self._real_repository.get_missing_parent_inventories(
1021
 
            check_for_missing_texts=check_for_missing_texts)
1022
 
 
1023
 
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
1024
 
        self._ensure_real()
1025
 
        return self._real_repository.get_rev_id_for_revno(
1026
 
            revno, known_pair)
1027
 
 
1028
 
    def get_rev_id_for_revno(self, revno, known_pair):
1029
 
        """See Repository.get_rev_id_for_revno."""
1030
 
        path = self.bzrdir._path_for_remote_call(self._client)
1031
 
        try:
1032
 
            if self._client._medium._is_remote_before((1, 17)):
1033
 
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
1034
 
            response = self._call(
1035
 
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
1036
 
        except errors.UnknownSmartMethod:
1037
 
            self._client._medium._remember_remote_is_before((1, 17))
1038
 
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
1039
 
        if response[0] == 'ok':
1040
 
            return True, response[1]
1041
 
        elif response[0] == 'history-incomplete':
1042
 
            known_pair = response[1:3]
1043
 
            for fallback in self._fallback_repositories:
1044
 
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
1045
 
                if found:
1046
 
                    return True, result
1047
 
                else:
1048
 
                    known_pair = result
1049
 
            # Not found in any fallbacks
1050
 
            return False, known_pair
1051
 
        else:
1052
 
            raise errors.UnexpectedSmartServerResponse(response)
 
673
    def get_missing_parent_inventories(self):
 
674
        self._ensure_real()
 
675
        return self._real_repository.get_missing_parent_inventories()
1053
676
 
1054
677
    def _ensure_real(self):
1055
678
        """Ensure that there is a _real_repository set.
1065
688
        invocation. If in doubt chat to the bzr network team.
1066
689
        """
1067
690
        if self._real_repository is None:
1068
 
            if 'hpssvfs' in debug.debug_flags:
1069
 
                import traceback
1070
 
                warning('VFS Repository access triggered\n%s',
1071
 
                    ''.join(traceback.format_stack()))
1072
691
            self._unstacked_provider.missing_keys.clear()
1073
692
            self.bzrdir._ensure_real()
1074
693
            self._set_real_repository(
1080
699
    def find_text_key_references(self):
1081
700
        """Find the text key references within the repository.
1082
701
 
 
702
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
703
        revision_ids. Each altered file-ids has the exact revision_ids that
 
704
        altered it listed explicitly.
1083
705
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1084
706
            to whether they were referred to by the inventory of the
1085
707
            revision_id that they contain. The inventory texts from all present
1103
725
        """Private method for using with old (< 1.2) servers to fallback."""
1104
726
        if revision_id is None:
1105
727
            revision_id = ''
1106
 
        elif _mod_revision.is_null(revision_id):
 
728
        elif revision.is_null(revision_id):
1107
729
            return {}
1108
730
 
1109
731
        path = self.bzrdir._path_for_remote_call(self._client)
1133
755
        return RemoteStreamSource(self, to_format)
1134
756
 
1135
757
    @needs_read_lock
1136
 
    def get_file_graph(self):
1137
 
        return graph.Graph(self.texts)
1138
 
 
1139
 
    @needs_read_lock
1140
758
    def has_revision(self, revision_id):
1141
759
        """True if this repository has a copy of the revision."""
1142
760
        # Copy of bzrlib.repository.Repository.has_revision
1156
774
            result.add(_mod_revision.NULL_REVISION)
1157
775
        return result
1158
776
 
1159
 
    def _has_same_fallbacks(self, other_repo):
1160
 
        """Returns true if the repositories have the same fallbacks."""
1161
 
        # XXX: copied from Repository; it should be unified into a base class
1162
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
1163
 
        my_fb = self._fallback_repositories
1164
 
        other_fb = other_repo._fallback_repositories
1165
 
        if len(my_fb) != len(other_fb):
1166
 
            return False
1167
 
        for f, g in zip(my_fb, other_fb):
1168
 
            if not f.has_same_location(g):
1169
 
                return False
1170
 
        return True
1171
 
 
1172
777
    def has_same_location(self, other):
1173
 
        # TODO: Move to RepositoryBase and unify with the regular Repository
1174
 
        # one; unfortunately the tests rely on slightly different behaviour at
1175
 
        # present -- mbp 20090710
1176
778
        return (self.__class__ is other.__class__ and
1177
779
                self.bzrdir.transport.base == other.bzrdir.transport.base)
1178
780
 
1181
783
        parents_provider = self._make_parents_provider(other_repository)
1182
784
        return graph.Graph(parents_provider)
1183
785
 
1184
 
    @needs_read_lock
1185
 
    def get_known_graph_ancestry(self, revision_ids):
1186
 
        """Return the known graph for a set of revision ids and their ancestors.
1187
 
        """
1188
 
        st = static_tuple.StaticTuple
1189
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
1190
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
1191
 
        return graph.GraphThunkIdsToKeys(known_graph)
1192
 
 
1193
786
    def gather_stats(self, revid=None, committers=None):
1194
787
        """See Repository.gather_stats()."""
1195
788
        path = self.bzrdir._path_for_remote_call(self._client)
1196
789
        # revid can be None to indicate no revisions, not just NULL_REVISION
1197
 
        if revid is None or _mod_revision.is_null(revid):
 
790
        if revid is None or revision.is_null(revid):
1198
791
            fmt_revid = ''
1199
792
        else:
1200
793
            fmt_revid = revid
1255
848
    def is_write_locked(self):
1256
849
        return self._lock_mode == 'w'
1257
850
 
1258
 
    def _warn_if_deprecated(self, branch=None):
1259
 
        # If we have a real repository, the check will be done there, if we
1260
 
        # don't the check will be done remotely.
1261
 
        pass
1262
 
 
1263
851
    def lock_read(self):
1264
 
        """Lock the repository for read operations.
1265
 
 
1266
 
        :return: A bzrlib.lock.LogicalLockResult.
1267
 
        """
1268
852
        # wrong eventually - want a local lock cache context
1269
853
        if not self._lock_mode:
1270
 
            self._note_lock('r')
1271
854
            self._lock_mode = 'r'
1272
855
            self._lock_count = 1
1273
856
            self._unstacked_provider.enable_cache(cache_misses=True)
1274
857
            if self._real_repository is not None:
1275
858
                self._real_repository.lock_read()
1276
 
            for repo in self._fallback_repositories:
1277
 
                repo.lock_read()
1278
859
        else:
1279
860
            self._lock_count += 1
1280
 
        return lock.LogicalLockResult(self.unlock)
 
861
        for repo in self._fallback_repositories:
 
862
            repo.lock_read()
1281
863
 
1282
864
    def _remote_lock_write(self, token):
1283
865
        path = self.bzrdir._path_for_remote_call(self._client)
1294
876
 
1295
877
    def lock_write(self, token=None, _skip_rpc=False):
1296
878
        if not self._lock_mode:
1297
 
            self._note_lock('w')
1298
879
            if _skip_rpc:
1299
880
                if self._lock_token is not None:
1300
881
                    if token != self._lock_token:
1316
897
            self._lock_count = 1
1317
898
            cache_misses = self._real_repository is None
1318
899
            self._unstacked_provider.enable_cache(cache_misses=cache_misses)
1319
 
            for repo in self._fallback_repositories:
1320
 
                # Writes don't affect fallback repos
1321
 
                repo.lock_read()
1322
900
        elif self._lock_mode == 'r':
1323
901
            raise errors.ReadOnlyError(self)
1324
902
        else:
1325
903
            self._lock_count += 1
1326
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
904
        for repo in self._fallback_repositories:
 
905
            # Writes don't affect fallback repos
 
906
            repo.lock_read()
 
907
        return self._lock_token or None
1327
908
 
1328
909
    def leave_lock_in_place(self):
1329
910
        if not self._lock_token:
1403
984
        else:
1404
985
            raise errors.UnexpectedSmartServerResponse(response)
1405
986
 
1406
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1407
987
    def unlock(self):
1408
988
        if not self._lock_count:
1409
 
            return lock.cant_unlock_not_held(self)
 
989
            raise errors.LockNotHeld(self)
1410
990
        self._lock_count -= 1
1411
991
        if self._lock_count > 0:
1412
992
            return
1431
1011
                self._lock_token = None
1432
1012
                if not self._leave_lock:
1433
1013
                    self._unlock(old_token)
1434
 
        # Fallbacks are always 'lock_read()' so we don't pay attention to
1435
 
        # self._leave_lock
1436
 
        for repo in self._fallback_repositories:
1437
 
            repo.unlock()
1438
1014
 
1439
1015
    def break_lock(self):
1440
1016
        # should hand off to the network
1483
1059
 
1484
1060
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1485
1061
                           timezone=None, committer=None, revprops=None,
1486
 
                           revision_id=None, lossy=False):
 
1062
                           revision_id=None):
1487
1063
        # FIXME: It ought to be possible to call this without immediately
1488
1064
        # triggering _ensure_real.  For now it's the easiest thing to do.
1489
1065
        self._ensure_real()
1490
1066
        real_repo = self._real_repository
1491
1067
        builder = real_repo.get_commit_builder(branch, parents,
1492
1068
                config, timestamp=timestamp, timezone=timezone,
1493
 
                committer=committer, revprops=revprops,
1494
 
                revision_id=revision_id, lossy=lossy)
 
1069
                committer=committer, revprops=revprops, revision_id=revision_id)
1495
1070
        return builder
1496
1071
 
1497
1072
    def add_fallback_repository(self, repository):
1505
1080
        # We need to accumulate additional repositories here, to pass them in
1506
1081
        # on various RPC's.
1507
1082
        #
1508
 
        if self.is_locked():
1509
 
            # We will call fallback.unlock() when we transition to the unlocked
1510
 
            # state, so always add a lock here. If a caller passes us a locked
1511
 
            # repository, they are responsible for unlocking it later.
1512
 
            repository.lock_read()
1513
 
        self._check_fallback_repository(repository)
1514
1083
        self._fallback_repositories.append(repository)
1515
1084
        # If self._real_repository was parameterised already (e.g. because a
1516
1085
        # _real_branch had its get_stacked_on_url method called), then the
1517
1086
        # repository to be added may already be in the _real_repositories list.
1518
1087
        if self._real_repository is not None:
1519
 
            fallback_locations = [repo.user_url for repo in
 
1088
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1520
1089
                self._real_repository._fallback_repositories]
1521
 
            if repository.user_url not in fallback_locations:
 
1090
            if repository.bzrdir.root_transport.base not in fallback_locations:
1522
1091
                self._real_repository.add_fallback_repository(repository)
1523
1092
 
1524
 
    def _check_fallback_repository(self, repository):
1525
 
        """Check that this repository can fallback to repository safely.
1526
 
 
1527
 
        Raise an error if not.
1528
 
 
1529
 
        :param repository: A repository to fallback to.
1530
 
        """
1531
 
        return _mod_repository.InterRepository._assert_same_model(
1532
 
            self, repository)
1533
 
 
1534
1093
    def add_inventory(self, revid, inv, parents):
1535
1094
        self._ensure_real()
1536
1095
        return self._real_repository.add_inventory(revid, inv, parents)
1537
1096
 
1538
1097
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1539
 
            parents, basis_inv=None, propagate_caches=False):
 
1098
                               parents):
1540
1099
        self._ensure_real()
1541
1100
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1542
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1543
 
            propagate_caches=propagate_caches)
 
1101
            delta, new_revision_id, parents)
1544
1102
 
1545
1103
    def add_revision(self, rev_id, rev, inv=None, config=None):
1546
1104
        self._ensure_real()
1552
1110
        self._ensure_real()
1553
1111
        return self._real_repository.get_inventory(revision_id)
1554
1112
 
1555
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1113
    def iter_inventories(self, revision_ids):
1556
1114
        self._ensure_real()
1557
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1115
        return self._real_repository.iter_inventories(revision_ids)
1558
1116
 
1559
1117
    @needs_read_lock
1560
1118
    def get_revision(self, revision_id):
1576
1134
        return self._real_repository.make_working_trees()
1577
1135
 
1578
1136
    def refresh_data(self):
1579
 
        """Re-read any data needed to synchronise with disk.
 
1137
        """Re-read any data needed to to synchronise with disk.
1580
1138
 
1581
1139
        This method is intended to be called after another repository instance
1582
1140
        (such as one used by a smart server) has inserted data into the
1583
 
        repository. On all repositories this will work outside of write groups.
1584
 
        Some repository formats (pack and newer for bzrlib native formats)
1585
 
        support refresh_data inside write groups. If called inside a write
1586
 
        group on a repository that does not support refreshing in a write group
1587
 
        IsInWriteGroupError will be raised.
 
1141
        repository. It may not be called during a write group, but may be
 
1142
        called at any other time.
1588
1143
        """
 
1144
        if self.is_in_write_group():
 
1145
            raise errors.InternalBzrError(
 
1146
                "May not refresh_data while in a write group.")
1589
1147
        if self._real_repository is not None:
1590
1148
            self._real_repository.refresh_data()
1591
1149
 
1603
1161
        return result
1604
1162
 
1605
1163
    @needs_read_lock
1606
 
    def search_missing_revision_ids(self, other,
1607
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1608
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1609
 
            limit=None):
 
1164
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1610
1165
        """Return the revision ids that other has that this does not.
1611
1166
 
1612
1167
        These are returned in topological order.
1613
1168
 
1614
1169
        revision_id: only return revision ids included by revision_id.
1615
1170
        """
1616
 
        if symbol_versioning.deprecated_passed(revision_id):
1617
 
            symbol_versioning.warn(
1618
 
                'search_missing_revision_ids(revision_id=...) was '
1619
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
1620
 
                DeprecationWarning, stacklevel=2)
1621
 
            if revision_ids is not None:
1622
 
                raise AssertionError(
1623
 
                    'revision_ids is mutually exclusive with revision_id')
1624
 
            if revision_id is not None:
1625
 
                revision_ids = [revision_id]
1626
 
        inter_repo = _mod_repository.InterRepository.get(other, self)
1627
 
        return inter_repo.search_missing_revision_ids(
1628
 
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1629
 
            if_present_ids=if_present_ids, limit=limit)
 
1171
        return repository.InterRepository.get(
 
1172
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
1630
1173
 
1631
 
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
1174
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1632
1175
            fetch_spec=None):
1633
1176
        # No base implementation to use as RemoteRepository is not a subclass
1634
1177
        # of Repository; so this is a copy of Repository.fetch().
1639
1182
            raise errors.InternalBzrError(
1640
1183
                "May not fetch while in a write group.")
1641
1184
        # fast path same-url fetch operations
1642
 
        if (self.has_same_location(source)
1643
 
            and fetch_spec is None
1644
 
            and self._has_same_fallbacks(source)):
 
1185
        if self.has_same_location(source) and fetch_spec is None:
1645
1186
            # check that last_revision is in 'from' and then return a
1646
1187
            # no-operation.
1647
1188
            if (revision_id is not None and
1648
 
                not _mod_revision.is_null(revision_id)):
 
1189
                not revision.is_null(revision_id)):
1649
1190
                self.get_revision(revision_id)
1650
1191
            return 0, []
1651
1192
        # if there is no specific appropriate InterRepository, this will get
1652
1193
        # the InterRepository base class, which raises an
1653
1194
        # IncompatibleRepositories when asked to fetch.
1654
 
        inter = _mod_repository.InterRepository.get(source, self)
1655
 
        return inter.fetch(revision_id=revision_id,
 
1195
        inter = repository.InterRepository.get(source, self)
 
1196
        return inter.fetch(revision_id=revision_id, pb=pb,
1656
1197
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1657
1198
 
1658
1199
    def create_bundle(self, target, base, fileobj, format=None):
1660
1201
        self._real_repository.create_bundle(target, base, fileobj, format)
1661
1202
 
1662
1203
    @needs_read_lock
1663
 
    @symbol_versioning.deprecated_method(
1664
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1665
1204
    def get_ancestry(self, revision_id, topo_sorted=True):
1666
1205
        self._ensure_real()
1667
1206
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1822
1361
        return self._real_repository.get_signature_text(revision_id)
1823
1362
 
1824
1363
    @needs_read_lock
1825
 
    def _get_inventory_xml(self, revision_id):
1826
 
        self._ensure_real()
1827
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1364
    def get_inventory_xml(self, revision_id):
 
1365
        self._ensure_real()
 
1366
        return self._real_repository.get_inventory_xml(revision_id)
 
1367
 
 
1368
    def deserialise_inventory(self, revision_id, xml):
 
1369
        self._ensure_real()
 
1370
        return self._real_repository.deserialise_inventory(revision_id, xml)
1828
1371
 
1829
1372
    def reconcile(self, other=None, thorough=False):
1830
1373
        self._ensure_real()
1857
1400
        return self._real_repository.get_revision_reconcile(revision_id)
1858
1401
 
1859
1402
    @needs_read_lock
1860
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1403
    def check(self, revision_ids=None):
1861
1404
        self._ensure_real()
1862
 
        return self._real_repository.check(revision_ids=revision_ids,
1863
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1405
        return self._real_repository.check(revision_ids=revision_ids)
1864
1406
 
1865
1407
    def copy_content_into(self, destination, revision_id=None):
1866
1408
        self._ensure_real()
1884
1426
            tmpdir = osutils.mkdtemp()
1885
1427
            try:
1886
1428
                _extract_tar(tar, tmpdir)
1887
 
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
 
1429
                tmp_bzrdir = BzrDir.open(tmpdir)
1888
1430
                tmp_repo = tmp_bzrdir.open_repository()
1889
1431
                tmp_repo.copy_content_into(destination, revision_id)
1890
1432
            finally:
1906
1448
        return self._real_repository.inventories
1907
1449
 
1908
1450
    @needs_write_lock
1909
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1451
    def pack(self):
1910
1452
        """Compress the data within the repository.
1911
1453
 
1912
1454
        This is not currently implemented within the smart server.
1913
1455
        """
1914
1456
        self._ensure_real()
1915
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1457
        return self._real_repository.pack()
1916
1458
 
1917
1459
    @property
1918
1460
    def revisions(self):
1975
1517
    def supports_rich_root(self):
1976
1518
        return self._format.rich_root_data
1977
1519
 
1978
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1979
1520
    def iter_reverse_revision_history(self, revision_id):
1980
1521
        self._ensure_real()
1981
1522
        return self._real_repository.iter_reverse_revision_history(revision_id)
2002
1543
        return self._real_repository.item_keys_introduced_by(revision_ids,
2003
1544
            _files_pb=_files_pb)
2004
1545
 
2005
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
2006
 
        self._ensure_real()
2007
 
        return self._real_repository._find_inconsistent_revision_parents(
2008
 
            revisions_iterator)
 
1546
    def revision_graph_can_have_wrong_parents(self):
 
1547
        # The answer depends on the remote repo format.
 
1548
        self._ensure_real()
 
1549
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
1550
 
 
1551
    def _find_inconsistent_revision_parents(self):
 
1552
        self._ensure_real()
 
1553
        return self._real_repository._find_inconsistent_revision_parents()
2009
1554
 
2010
1555
    def _check_for_inconsistent_revision_parents(self):
2011
1556
        self._ensure_real()
2015
1560
        providers = [self._unstacked_provider]
2016
1561
        if other is not None:
2017
1562
            providers.insert(0, other)
2018
 
        return graph.StackedParentsProvider(_LazyListJoin(
2019
 
            providers, self._fallback_repositories))
 
1563
        providers.extend(r._make_parents_provider() for r in
 
1564
                         self._fallback_repositories)
 
1565
        return graph._StackedParentsProvider(providers)
2020
1566
 
2021
1567
    def _serialise_search_recipe(self, recipe):
2022
1568
        """Serialise a graph search recipe.
2030
1576
        return '\n'.join((start_keys, stop_keys, count))
2031
1577
 
2032
1578
    def _serialise_search_result(self, search_result):
2033
 
        parts = search_result.get_network_struct()
 
1579
        if isinstance(search_result, graph.PendingAncestryResult):
 
1580
            parts = ['ancestry-of']
 
1581
            parts.extend(search_result.heads)
 
1582
        else:
 
1583
            recipe = search_result.get_recipe()
 
1584
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
2034
1585
        return '\n'.join(parts)
2035
1586
 
2036
1587
    def autopack(self):
2046
1597
            raise errors.UnexpectedSmartServerResponse(response)
2047
1598
 
2048
1599
 
2049
 
class RemoteStreamSink(vf_repository.StreamSink):
 
1600
class RemoteStreamSink(repository.StreamSink):
2050
1601
 
2051
1602
    def _insert_real(self, stream, src_format, resume_tokens):
2052
1603
        self.target_repo._ensure_real()
2059
1610
    def insert_stream(self, stream, src_format, resume_tokens):
2060
1611
        target = self.target_repo
2061
1612
        target._unstacked_provider.missing_keys.clear()
2062
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
2063
1613
        if target._lock_token:
2064
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
2065
 
            lock_args = (target._lock_token or '',)
 
1614
            verb = 'Repository.insert_stream_locked'
 
1615
            extra_args = (target._lock_token or '',)
 
1616
            required_version = (1, 14)
2066
1617
        else:
2067
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
2068
 
            lock_args = ()
 
1618
            verb = 'Repository.insert_stream'
 
1619
            extra_args = ()
 
1620
            required_version = (1, 13)
2069
1621
        client = target._client
2070
1622
        medium = client._medium
 
1623
        if medium._is_remote_before(required_version):
 
1624
            # No possible way this can work.
 
1625
            return self._insert_real(stream, src_format, resume_tokens)
2071
1626
        path = target.bzrdir._path_for_remote_call(client)
2072
 
        # Probe for the verb to use with an empty stream before sending the
2073
 
        # real stream to it.  We do this both to avoid the risk of sending a
2074
 
        # large request that is then rejected, and because we don't want to
2075
 
        # implement a way to buffer, rewind, or restart the stream.
2076
 
        found_verb = False
2077
 
        for verb, required_version in candidate_calls:
2078
 
            if medium._is_remote_before(required_version):
2079
 
                continue
2080
 
            if resume_tokens:
2081
 
                # We've already done the probing (and set _is_remote_before) on
2082
 
                # a previous insert.
2083
 
                found_verb = True
2084
 
                break
 
1627
        if not resume_tokens:
 
1628
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1629
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1630
            # fallback to the _real_repositories sink *with a partial stream*.
 
1631
            # Thats bad because we insert less data than bzr expected. To avoid
 
1632
            # this we do a trial push to make sure the verb is accessible, and
 
1633
            # do not fallback when actually pushing the stream. A cleanup patch
 
1634
            # is going to look at rewinding/restarting the stream/partial
 
1635
            # buffering etc.
2085
1636
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
2086
1637
            try:
2087
1638
                response = client.call_with_body_stream(
2088
 
                    (verb, path, '') + lock_args, byte_stream)
 
1639
                    (verb, path, '') + extra_args, byte_stream)
2089
1640
            except errors.UnknownSmartMethod:
2090
1641
                medium._remember_remote_is_before(required_version)
2091
 
            else:
2092
 
                found_verb = True
2093
 
                break
2094
 
        if not found_verb:
2095
 
            # Have to use VFS.
2096
 
            return self._insert_real(stream, src_format, resume_tokens)
2097
 
        self._last_inv_record = None
2098
 
        self._last_substream = None
2099
 
        if required_version < (1, 19):
2100
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
2101
 
            # make sure we don't send any.  If the stream contains inventory
2102
 
            # deltas we'll interrupt the smart insert_stream request and
2103
 
            # fallback to VFS.
2104
 
            stream = self._stop_stream_if_inventory_delta(stream)
 
1642
                return self._insert_real(stream, src_format, resume_tokens)
2105
1643
        byte_stream = smart_repo._stream_to_byte_stream(
2106
1644
            stream, src_format)
2107
1645
        resume_tokens = ' '.join(resume_tokens)
2108
1646
        response = client.call_with_body_stream(
2109
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1647
            (verb, path, resume_tokens) + extra_args, byte_stream)
2110
1648
        if response[0][0] not in ('ok', 'missing-basis'):
2111
1649
            raise errors.UnexpectedSmartServerResponse(response)
2112
 
        if self._last_substream is not None:
2113
 
            # The stream included an inventory-delta record, but the remote
2114
 
            # side isn't new enough to support them.  So we need to send the
2115
 
            # rest of the stream via VFS.
2116
 
            self.target_repo.refresh_data()
2117
 
            return self._resume_stream_with_vfs(response, src_format)
2118
1650
        if response[0][0] == 'missing-basis':
2119
1651
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
2120
1652
            resume_tokens = tokens
2123
1655
            self.target_repo.refresh_data()
2124
1656
            return [], set()
2125
1657
 
2126
 
    def _resume_stream_with_vfs(self, response, src_format):
2127
 
        """Resume sending a stream via VFS, first resending the record and
2128
 
        substream that couldn't be sent via an insert_stream verb.
2129
 
        """
2130
 
        if response[0][0] == 'missing-basis':
2131
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
2132
 
            # Ignore missing_keys, we haven't finished inserting yet
2133
 
        else:
2134
 
            tokens = []
2135
 
        def resume_substream():
2136
 
            # Yield the substream that was interrupted.
2137
 
            for record in self._last_substream:
2138
 
                yield record
2139
 
            self._last_substream = None
2140
 
        def resume_stream():
2141
 
            # Finish sending the interrupted substream
2142
 
            yield ('inventory-deltas', resume_substream())
2143
 
            # Then simply continue sending the rest of the stream.
2144
 
            for substream_kind, substream in self._last_stream:
2145
 
                yield substream_kind, substream
2146
 
        return self._insert_real(resume_stream(), src_format, tokens)
2147
 
 
2148
 
    def _stop_stream_if_inventory_delta(self, stream):
2149
 
        """Normally this just lets the original stream pass-through unchanged.
2150
 
 
2151
 
        However if any 'inventory-deltas' substream occurs it will stop
2152
 
        streaming, and store the interrupted substream and stream in
2153
 
        self._last_substream and self._last_stream so that the stream can be
2154
 
        resumed by _resume_stream_with_vfs.
2155
 
        """
2156
 
 
2157
 
        stream_iter = iter(stream)
2158
 
        for substream_kind, substream in stream_iter:
2159
 
            if substream_kind == 'inventory-deltas':
2160
 
                self._last_substream = substream
2161
 
                self._last_stream = stream_iter
2162
 
                return
2163
 
            else:
2164
 
                yield substream_kind, substream
2165
 
 
2166
 
 
2167
 
class RemoteStreamSource(vf_repository.StreamSource):
 
1658
 
 
1659
class RemoteStreamSource(repository.StreamSource):
2168
1660
    """Stream data from a remote server."""
2169
1661
 
2170
1662
    def get_stream(self, search):
2171
1663
        if (self.from_repository._fallback_repositories and
2172
1664
            self.to_format._fetch_order == 'topological'):
2173
1665
            return self._real_stream(self.from_repository, search)
2174
 
        sources = []
2175
 
        seen = set()
2176
 
        repos = [self.from_repository]
2177
 
        while repos:
2178
 
            repo = repos.pop(0)
2179
 
            if repo in seen:
2180
 
                continue
2181
 
            seen.add(repo)
2182
 
            repos.extend(repo._fallback_repositories)
2183
 
            sources.append(repo)
2184
 
        return self.missing_parents_chain(search, sources)
2185
 
 
2186
 
    def get_stream_for_missing_keys(self, missing_keys):
2187
 
        self.from_repository._ensure_real()
2188
 
        real_repo = self.from_repository._real_repository
2189
 
        real_source = real_repo._get_source(self.to_format)
2190
 
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1666
        return self.missing_parents_chain(search, [self.from_repository] +
 
1667
            self.from_repository._fallback_repositories)
2191
1668
 
2192
1669
    def _real_stream(self, repo, search):
2193
1670
        """Get a stream for search from repo.
2200
1677
        """
2201
1678
        source = repo._get_source(self.to_format)
2202
1679
        if isinstance(source, RemoteStreamSource):
2203
 
            repo._ensure_real()
2204
 
            source = repo._real_repository._get_source(self.to_format)
 
1680
            return repository.StreamSource.get_stream(source, search)
2205
1681
        return source.get_stream(search)
2206
1682
 
2207
1683
    def _get_stream(self, repo, search):
2224
1700
            return self._real_stream(repo, search)
2225
1701
        client = repo._client
2226
1702
        medium = client._medium
 
1703
        if medium._is_remote_before((1, 13)):
 
1704
            # streaming was added in 1.13
 
1705
            return self._real_stream(repo, search)
2227
1706
        path = repo.bzrdir._path_for_remote_call(client)
2228
 
        search_bytes = repo._serialise_search_result(search)
2229
 
        args = (path, self.to_format.network_name())
2230
 
        candidate_verbs = [
2231
 
            ('Repository.get_stream_1.19', (1, 19)),
2232
 
            ('Repository.get_stream', (1, 13))]
2233
 
 
2234
 
        found_verb = False
2235
 
        for verb, version in candidate_verbs:
2236
 
            if medium._is_remote_before(version):
2237
 
                continue
2238
 
            try:
2239
 
                response = repo._call_with_body_bytes_expecting_body(
2240
 
                    verb, args, search_bytes)
2241
 
            except errors.UnknownSmartMethod:
2242
 
                medium._remember_remote_is_before(version)
2243
 
            except errors.UnknownErrorFromSmartServer, e:
2244
 
                if isinstance(search, graph.EverythingResult):
2245
 
                    error_verb = e.error_from_smart_server.error_verb
2246
 
                    if error_verb == 'BadSearch':
2247
 
                        # Pre-2.4 servers don't support this sort of search.
2248
 
                        # XXX: perhaps falling back to VFS on BadSearch is a
2249
 
                        # good idea in general?  It might provide a little bit
2250
 
                        # of protection against client-side bugs.
2251
 
                        medium._remember_remote_is_before((2, 4))
2252
 
                        break
2253
 
                raise
2254
 
            else:
2255
 
                response_tuple, response_handler = response
2256
 
                found_verb = True
2257
 
                break
2258
 
        if not found_verb:
 
1707
        try:
 
1708
            search_bytes = repo._serialise_search_result(search)
 
1709
            response = repo._call_with_body_bytes_expecting_body(
 
1710
                'Repository.get_stream',
 
1711
                (path, self.to_format.network_name()), search_bytes)
 
1712
            response_tuple, response_handler = response
 
1713
        except errors.UnknownSmartMethod:
 
1714
            medium._remember_remote_is_before((1,13))
2259
1715
            return self._real_stream(repo, search)
2260
1716
        if response_tuple[0] != 'ok':
2261
1717
            raise errors.UnexpectedSmartServerResponse(response_tuple)
2262
1718
        byte_stream = response_handler.read_streamed_body()
2263
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
2264
 
            self._record_counter)
 
1719
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
2265
1720
        if src_format.network_name() != repo._format.network_name():
2266
1721
            raise AssertionError(
2267
1722
                "Mismatched RemoteRepository and stream src %r, %r" % (
2274
1729
        :param search: The overall search to satisfy with streams.
2275
1730
        :param sources: A list of Repository objects to query.
2276
1731
        """
2277
 
        self.from_serialiser = self.from_repository._format._serializer
 
1732
        self.serialiser = self.to_format._serializer
2278
1733
        self.seen_revs = set()
2279
1734
        self.referenced_revs = set()
2280
1735
        # If there are heads in the search, or the key count is > 0, we are not
2297
1752
    def missing_parents_rev_handler(self, substream):
2298
1753
        for content in substream:
2299
1754
            revision_bytes = content.get_bytes_as('fulltext')
2300
 
            revision = self.from_serialiser.read_revision_from_string(
2301
 
                revision_bytes)
 
1755
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2302
1756
            self.seen_revs.add(content.key[-1])
2303
1757
            self.referenced_revs.update(revision.parent_ids)
2304
1758
            yield content
2343
1797
                self._network_name)
2344
1798
 
2345
1799
    def get_format_description(self):
2346
 
        self._ensure_real()
2347
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1800
        return 'Remote BZR Branch'
2348
1801
 
2349
1802
    def network_name(self):
2350
1803
        return self._network_name
2351
1804
 
2352
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2353
 
        return a_bzrdir.open_branch(name=name, 
2354
 
            ignore_fallbacks=ignore_fallbacks)
 
1805
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1806
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2355
1807
 
2356
 
    def _vfs_initialize(self, a_bzrdir, name):
 
1808
    def _vfs_initialize(self, a_bzrdir):
2357
1809
        # Initialisation when using a local bzrdir object, or a non-vfs init
2358
1810
        # method is not available on the server.
2359
1811
        # self._custom_format is always set - the start of initialize ensures
2360
1812
        # that.
2361
1813
        if isinstance(a_bzrdir, RemoteBzrDir):
2362
1814
            a_bzrdir._ensure_real()
2363
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2364
 
                name)
 
1815
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2365
1816
        else:
2366
1817
            # We assume the bzrdir is parameterised; it may not be.
2367
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
1818
            result = self._custom_format.initialize(a_bzrdir)
2368
1819
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2369
1820
            not isinstance(result, RemoteBranch)):
2370
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2371
 
                                  name=name)
 
1821
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2372
1822
        return result
2373
1823
 
2374
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
1824
    def initialize(self, a_bzrdir):
2375
1825
        # 1) get the network name to use.
2376
1826
        if self._custom_format:
2377
1827
            network_name = self._custom_format.network_name()
2378
1828
        else:
2379
1829
            # Select the current bzrlib default and ask for that.
2380
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
1830
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
2381
1831
            reference_format = reference_bzrdir_format.get_branch_format()
2382
1832
            self._custom_format = reference_format
2383
1833
            network_name = reference_format.network_name()
2384
1834
        # Being asked to create on a non RemoteBzrDir:
2385
1835
        if not isinstance(a_bzrdir, RemoteBzrDir):
2386
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1836
            return self._vfs_initialize(a_bzrdir)
2387
1837
        medium = a_bzrdir._client._medium
2388
1838
        if medium._is_remote_before((1, 13)):
2389
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1839
            return self._vfs_initialize(a_bzrdir)
2390
1840
        # Creating on a remote bzr dir.
2391
1841
        # 2) try direct creation via RPC
2392
1842
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2393
 
        if name is not None:
2394
 
            # XXX JRV20100304: Support creating colocated branches
2395
 
            raise errors.NoColocatedBranchSupport(self)
2396
1843
        verb = 'BzrDir.create_branch'
2397
1844
        try:
2398
1845
            response = a_bzrdir._call(verb, path, network_name)
2399
1846
        except errors.UnknownSmartMethod:
2400
1847
            # Fallback - use vfs methods
2401
1848
            medium._remember_remote_is_before((1, 13))
2402
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
1849
            return self._vfs_initialize(a_bzrdir)
2403
1850
        if response[0] != 'ok':
2404
1851
            raise errors.UnexpectedSmartServerResponse(response)
2405
1852
        # Turn the response into a RemoteRepository object.
2406
1853
        format = RemoteBranchFormat(network_name=response[1])
2407
1854
        repo_format = response_tuple_to_repo_format(response[3:])
2408
 
        repo_path = response[2]
2409
 
        if repository is not None:
2410
 
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
2411
 
            url_diff = urlutils.relative_url(repository.user_url,
2412
 
                    remote_repo_url)
2413
 
            if url_diff != '.':
2414
 
                raise AssertionError(
2415
 
                    'repository.user_url %r does not match URL from server '
2416
 
                    'response (%r + %r)'
2417
 
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
2418
 
            remote_repo = repository
 
1855
        if response[2] == '':
 
1856
            repo_bzrdir = a_bzrdir
2419
1857
        else:
2420
 
            if repo_path == '':
2421
 
                repo_bzrdir = a_bzrdir
2422
 
            else:
2423
 
                repo_bzrdir = RemoteBzrDir(
2424
 
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
2425
 
                    a_bzrdir._client)
2426
 
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
1858
            repo_bzrdir = RemoteBzrDir(
 
1859
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
 
1860
                a_bzrdir._client)
 
1861
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2427
1862
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2428
 
            format=format, setup_stacking=False, name=name)
 
1863
            format=format, setup_stacking=False)
2429
1864
        # XXX: We know this is a new branch, so it must have revno 0, revid
2430
1865
        # NULL_REVISION. Creating the branch locked would make this be unable
2431
1866
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2446
1881
        self._ensure_real()
2447
1882
        return self._custom_format.supports_stacking()
2448
1883
 
2449
 
    def supports_set_append_revisions_only(self):
2450
 
        self._ensure_real()
2451
 
        return self._custom_format.supports_set_append_revisions_only()
2452
 
 
2453
 
    def _use_default_local_heads_to_fetch(self):
2454
 
        # If the branch format is a metadir format *and* its heads_to_fetch
2455
 
        # implementation is not overridden vs the base class, we can use the
2456
 
        # base class logic rather than use the heads_to_fetch RPC.  This is
2457
 
        # usually cheaper in terms of net round trips, as the last-revision and
2458
 
        # tags info fetched is cached and would be fetched anyway.
2459
 
        self._ensure_real()
2460
 
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
2461
 
            branch_class = self._custom_format._branch_class()
2462
 
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
2463
 
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
2464
 
                return True
2465
 
        return False
2466
 
 
2467
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1884
 
 
1885
class RemoteBranch(branch.Branch, _RpcHelper):
2468
1886
    """Branch stored on a server accessed by HPSS RPC.
2469
1887
 
2470
1888
    At the moment most operations are mapped down to simple file operations.
2471
1889
    """
2472
1890
 
2473
1891
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2474
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1892
        _client=None, format=None, setup_stacking=True):
2475
1893
        """Create a RemoteBranch instance.
2476
1894
 
2477
1895
        :param real_branch: An optional local implementation of the branch
2483
1901
        :param setup_stacking: If True make an RPC call to determine the
2484
1902
            stacked (or not) status of the branch. If False assume the branch
2485
1903
            is not stacked.
2486
 
        :param name: Colocated branch name
2487
1904
        """
2488
1905
        # We intentionally don't call the parent class's __init__, because it
2489
1906
        # will try to assign to self.tags, which is a property in this subclass.
2490
1907
        # And the parent's __init__ doesn't do much anyway.
 
1908
        self._revision_id_to_revno_cache = None
 
1909
        self._partial_revision_id_to_revno_cache = {}
 
1910
        self._revision_history_cache = None
 
1911
        self._last_revision_info_cache = None
 
1912
        self._merge_sorted_revisions_cache = None
2491
1913
        self.bzrdir = remote_bzrdir
2492
1914
        if _client is not None:
2493
1915
            self._client = _client
2507
1929
        else:
2508
1930
            self._real_branch = None
2509
1931
        # Fill out expected attributes of branch for bzrlib API users.
2510
 
        self._clear_cached_state()
2511
 
        # TODO: deprecate self.base in favor of user_url
2512
 
        self.base = self.bzrdir.user_url
2513
 
        self._name = name
 
1932
        self.base = self.bzrdir.root_transport.base
2514
1933
        self._control_files = None
2515
1934
        self._lock_mode = None
2516
1935
        self._lock_token = None
2527
1946
                    self._real_branch._format.network_name()
2528
1947
        else:
2529
1948
            self._format = format
2530
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2531
 
        # branch.open_branch method.
2532
 
        self._real_ignore_fallbacks = not setup_stacking
2533
1949
        if not self._format._network_name:
2534
1950
            # Did not get from open_branchV2 - old server.
2535
1951
            self._ensure_real()
2540
1956
        hooks = branch.Branch.hooks['open']
2541
1957
        for hook in hooks:
2542
1958
            hook(self)
2543
 
        self._is_stacked = False
2544
1959
        if setup_stacking:
2545
1960
            self._setup_stacking()
2546
1961
 
2552
1967
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2553
1968
            errors.UnstackableRepositoryFormat), e:
2554
1969
            return
2555
 
        self._is_stacked = True
2556
 
        self._activate_fallback_location(fallback_url)
 
1970
        self._activate_fallback_location(fallback_url, None)
2557
1971
 
2558
1972
    def _get_config(self):
2559
1973
        return RemoteBranchConfig(self)
2580
1994
                raise AssertionError('smart server vfs must be enabled '
2581
1995
                    'to use vfs implementation')
2582
1996
            self.bzrdir._ensure_real()
2583
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2584
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
1997
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2585
1998
            if self.repository._real_repository is None:
2586
1999
                # Give the remote repository the matching real repo.
2587
2000
                real_repo = self._real_branch.repository
2661
2074
            raise errors.UnexpectedSmartServerResponse(response)
2662
2075
        return response[1]
2663
2076
 
2664
 
    def set_stacked_on_url(self, url):
2665
 
        branch.Branch.set_stacked_on_url(self, url)
2666
 
        if not url:
2667
 
            self._is_stacked = False
2668
 
        else:
2669
 
            self._is_stacked = True
2670
 
 
2671
2077
    def _vfs_get_tags_bytes(self):
2672
2078
        self._ensure_real()
2673
2079
        return self._real_branch._get_tags_bytes()
2674
2080
 
2675
 
    @needs_read_lock
2676
2081
    def _get_tags_bytes(self):
2677
 
        if self._tags_bytes is None:
2678
 
            self._tags_bytes = self._get_tags_bytes_via_hpss()
2679
 
        return self._tags_bytes
2680
 
 
2681
 
    def _get_tags_bytes_via_hpss(self):
2682
2082
        medium = self._client._medium
2683
2083
        if medium._is_remote_before((1, 13)):
2684
2084
            return self._vfs_get_tags_bytes()
2689
2089
            return self._vfs_get_tags_bytes()
2690
2090
        return response[0]
2691
2091
 
2692
 
    def _vfs_set_tags_bytes(self, bytes):
2693
 
        self._ensure_real()
2694
 
        return self._real_branch._set_tags_bytes(bytes)
2695
 
 
2696
 
    def _set_tags_bytes(self, bytes):
2697
 
        if self.is_locked():
2698
 
            self._tags_bytes = bytes
2699
 
        medium = self._client._medium
2700
 
        if medium._is_remote_before((1, 18)):
2701
 
            self._vfs_set_tags_bytes(bytes)
2702
 
            return
2703
 
        try:
2704
 
            args = (
2705
 
                self._remote_path(), self._lock_token, self._repo_lock_token)
2706
 
            response = self._call_with_body_bytes(
2707
 
                'Branch.set_tags_bytes', args, bytes)
2708
 
        except errors.UnknownSmartMethod:
2709
 
            medium._remember_remote_is_before((1, 18))
2710
 
            self._vfs_set_tags_bytes(bytes)
2711
 
 
2712
2092
    def lock_read(self):
2713
 
        """Lock the branch for read operations.
2714
 
 
2715
 
        :return: A bzrlib.lock.LogicalLockResult.
2716
 
        """
2717
2093
        self.repository.lock_read()
2718
2094
        if not self._lock_mode:
2719
 
            self._note_lock('r')
2720
2095
            self._lock_mode = 'r'
2721
2096
            self._lock_count = 1
2722
2097
            if self._real_branch is not None:
2723
2098
                self._real_branch.lock_read()
2724
2099
        else:
2725
2100
            self._lock_count += 1
2726
 
        return lock.LogicalLockResult(self.unlock)
2727
2101
 
2728
2102
    def _remote_lock_write(self, token):
2729
2103
        if token is None:
2730
2104
            branch_token = repo_token = ''
2731
2105
        else:
2732
2106
            branch_token = token
2733
 
            repo_token = self.repository.lock_write().repository_token
 
2107
            repo_token = self.repository.lock_write()
2734
2108
            self.repository.unlock()
2735
2109
        err_context = {'token': token}
2736
 
        try:
2737
 
            response = self._call(
2738
 
                'Branch.lock_write', self._remote_path(), branch_token,
2739
 
                repo_token or '', **err_context)
2740
 
        except errors.LockContention, e:
2741
 
            # The LockContention from the server doesn't have any
2742
 
            # information about the lock_url. We re-raise LockContention
2743
 
            # with valid lock_url.
2744
 
            raise errors.LockContention('(remote lock)',
2745
 
                self.repository.base.split('.bzr/')[0])
 
2110
        response = self._call(
 
2111
            'Branch.lock_write', self._remote_path(), branch_token,
 
2112
            repo_token or '', **err_context)
2746
2113
        if response[0] != 'ok':
2747
2114
            raise errors.UnexpectedSmartServerResponse(response)
2748
2115
        ok, branch_token, repo_token = response
2750
2117
 
2751
2118
    def lock_write(self, token=None):
2752
2119
        if not self._lock_mode:
2753
 
            self._note_lock('w')
2754
2120
            # Lock the branch and repo in one remote call.
2755
2121
            remote_tokens = self._remote_lock_write(token)
2756
2122
            self._lock_token, self._repo_lock_token = remote_tokens
2769
2135
            self._lock_mode = 'w'
2770
2136
            self._lock_count = 1
2771
2137
        elif self._lock_mode == 'r':
2772
 
            raise errors.ReadOnlyError(self)
 
2138
            raise errors.ReadOnlyTransaction
2773
2139
        else:
2774
2140
            if token is not None:
2775
2141
                # A token was given to lock_write, and we're relocking, so
2780
2146
            self._lock_count += 1
2781
2147
            # Re-lock the repository too.
2782
2148
            self.repository.lock_write(self._repo_lock_token)
2783
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2149
        return self._lock_token or None
 
2150
 
 
2151
    def _set_tags_bytes(self, bytes):
 
2152
        self._ensure_real()
 
2153
        return self._real_branch._set_tags_bytes(bytes)
2784
2154
 
2785
2155
    def _unlock(self, branch_token, repo_token):
2786
2156
        err_context = {'token': str((branch_token, repo_token))}
2791
2161
            return
2792
2162
        raise errors.UnexpectedSmartServerResponse(response)
2793
2163
 
2794
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2795
2164
    def unlock(self):
2796
2165
        try:
2797
2166
            self._lock_count -= 1
2837
2206
            raise NotImplementedError(self.dont_leave_lock_in_place)
2838
2207
        self._leave_lock = False
2839
2208
 
2840
 
    @needs_read_lock
2841
 
    def get_rev_id(self, revno, history=None):
2842
 
        if revno == 0:
2843
 
            return _mod_revision.NULL_REVISION
2844
 
        last_revision_info = self.last_revision_info()
2845
 
        ok, result = self.repository.get_rev_id_for_revno(
2846
 
            revno, last_revision_info)
2847
 
        if ok:
2848
 
            return result
2849
 
        missing_parent = result[1]
2850
 
        # Either the revision named by the server is missing, or its parent
2851
 
        # is.  Call get_parent_map to determine which, so that we report a
2852
 
        # useful error.
2853
 
        parent_map = self.repository.get_parent_map([missing_parent])
2854
 
        if missing_parent in parent_map:
2855
 
            missing_parent = parent_map[missing_parent]
2856
 
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2857
 
 
2858
 
    def _read_last_revision_info(self):
 
2209
    def _last_revision_info(self):
2859
2210
        response = self._call('Branch.last_revision_info', self._remote_path())
2860
2211
        if response[0] != 'ok':
2861
2212
            raise SmartProtocolError('unexpected response code %s' % (response,))
2865
2216
 
2866
2217
    def _gen_revision_history(self):
2867
2218
        """See Branch._gen_revision_history()."""
2868
 
        if self._is_stacked:
2869
 
            self._ensure_real()
2870
 
            return self._real_branch._gen_revision_history()
2871
2219
        response_tuple, response_handler = self._call_expecting_body(
2872
2220
            'Branch.revision_history', self._remote_path())
2873
2221
        if response_tuple[0] != 'ok':
2924
2272
            raise errors.UnexpectedSmartServerResponse(response)
2925
2273
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2926
2274
 
2927
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2928
2275
    @needs_write_lock
2929
2276
    def set_revision_history(self, rev_history):
2930
 
        """See Branch.set_revision_history."""
2931
 
        self._set_revision_history(rev_history)
2932
 
 
2933
 
    @needs_write_lock
2934
 
    def _set_revision_history(self, rev_history):
2935
2277
        # Send just the tip revision of the history; the server will generate
2936
2278
        # the full history from that.  If the revision doesn't exist in this
2937
2279
        # branch, NoSuchRevision will be raised.
2995
2337
            _override_hook_target=self, **kwargs)
2996
2338
 
2997
2339
    @needs_read_lock
2998
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
 
2340
    def push(self, target, overwrite=False, stop_revision=None):
2999
2341
        self._ensure_real()
3000
2342
        return self._real_branch.push(
3001
 
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
 
2343
            target, overwrite=overwrite, stop_revision=stop_revision,
3002
2344
            _override_hook_source_branch=self)
3003
2345
 
3004
2346
    def is_locked(self):
3014
2356
        # XXX: These should be returned by the set_last_revision_info verb
3015
2357
        old_revno, old_revid = self.last_revision_info()
3016
2358
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
3017
 
        if not revision_id or not isinstance(revision_id, basestring):
3018
 
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2359
        revision_id = ensure_null(revision_id)
3019
2360
        try:
3020
2361
            response = self._call('Branch.set_last_revision_info',
3021
2362
                self._remote_path(), self._lock_token, self._repo_lock_token,
3050
2391
            except errors.UnknownSmartMethod:
3051
2392
                medium._remember_remote_is_before((1, 6))
3052
2393
        self._clear_cached_state_of_remote_branch_only()
3053
 
        self._set_revision_history(self._lefthand_history(revision_id,
 
2394
        self.set_revision_history(self._lefthand_history(revision_id,
3054
2395
            last_rev=last_rev,other_branch=other_branch))
3055
2396
 
3056
2397
    def set_push_location(self, location):
3057
2398
        self._ensure_real()
3058
2399
        return self._real_branch.set_push_location(location)
3059
2400
 
3060
 
    def heads_to_fetch(self):
3061
 
        if self._format._use_default_local_heads_to_fetch():
3062
 
            # We recognise this format, and its heads-to-fetch implementation
3063
 
            # is the default one (tip + tags).  In this case it's cheaper to
3064
 
            # just use the default implementation rather than a special RPC as
3065
 
            # the tip and tags data is cached.
3066
 
            return branch.Branch.heads_to_fetch(self)
3067
 
        medium = self._client._medium
3068
 
        if medium._is_remote_before((2, 4)):
3069
 
            return self._vfs_heads_to_fetch()
3070
 
        try:
3071
 
            return self._rpc_heads_to_fetch()
3072
 
        except errors.UnknownSmartMethod:
3073
 
            medium._remember_remote_is_before((2, 4))
3074
 
            return self._vfs_heads_to_fetch()
3075
 
 
3076
 
    def _rpc_heads_to_fetch(self):
3077
 
        response = self._call('Branch.heads_to_fetch', self._remote_path())
3078
 
        if len(response) != 2:
3079
 
            raise errors.UnexpectedSmartServerResponse(response)
3080
 
        must_fetch, if_present_fetch = response
3081
 
        return set(must_fetch), set(if_present_fetch)
3082
 
 
3083
 
    def _vfs_heads_to_fetch(self):
3084
 
        self._ensure_real()
3085
 
        return self._real_branch.heads_to_fetch()
3086
 
 
3087
2401
 
3088
2402
class RemoteConfig(object):
3089
2403
    """A Config that reads and writes from smart verbs.
3103
2417
        """
3104
2418
        try:
3105
2419
            configobj = self._get_configobj()
3106
 
            section_obj = None
3107
2420
            if section is None:
3108
2421
                section_obj = configobj
3109
2422
            else:
3110
2423
                try:
3111
2424
                    section_obj = configobj[section]
3112
2425
                except KeyError:
3113
 
                    pass
3114
 
            if section_obj is None:
3115
 
                value = default
3116
 
            else:
3117
 
                value = section_obj.get(name, default)
 
2426
                    return default
 
2427
            return section_obj.get(name, default)
3118
2428
        except errors.UnknownSmartMethod:
3119
 
            value = self._vfs_get_option(name, section, default)
3120
 
        for hook in config.OldConfigHooks['get']:
3121
 
            hook(self, name, value)
3122
 
        return value
 
2429
            return self._vfs_get_option(name, section, default)
3123
2430
 
3124
2431
    def _response_to_configobj(self, response):
3125
2432
        if len(response[0]) and response[0][0] != 'ok':
3126
2433
            raise errors.UnexpectedSmartServerResponse(response)
3127
2434
        lines = response[1].read_body_bytes().splitlines()
3128
 
        conf = config.ConfigObj(lines, encoding='utf-8')
3129
 
        for hook in config.OldConfigHooks['load']:
3130
 
            hook(self)
3131
 
        return conf
 
2435
        return config.ConfigObj(lines, encoding='utf-8')
3132
2436
 
3133
2437
 
3134
2438
class RemoteBranchConfig(RemoteConfig):
3153
2457
        medium = self._branch._client._medium
3154
2458
        if medium._is_remote_before((1, 14)):
3155
2459
            return self._vfs_set_option(value, name, section)
3156
 
        if isinstance(value, dict):
3157
 
            if medium._is_remote_before((2, 2)):
3158
 
                return self._vfs_set_option(value, name, section)
3159
 
            return self._set_config_option_dict(value, name, section)
3160
 
        else:
3161
 
            return self._set_config_option(value, name, section)
3162
 
 
3163
 
    def _set_config_option(self, value, name, section):
3164
2460
        try:
3165
2461
            path = self._branch._remote_path()
3166
2462
            response = self._branch._client.call('Branch.set_config_option',
3167
2463
                path, self._branch._lock_token, self._branch._repo_lock_token,
3168
2464
                value.encode('utf8'), name, section or '')
3169
2465
        except errors.UnknownSmartMethod:
3170
 
            medium = self._branch._client._medium
3171
2466
            medium._remember_remote_is_before((1, 14))
3172
2467
            return self._vfs_set_option(value, name, section)
3173
2468
        if response != ():
3174
2469
            raise errors.UnexpectedSmartServerResponse(response)
3175
2470
 
3176
 
    def _serialize_option_dict(self, option_dict):
3177
 
        utf8_dict = {}
3178
 
        for key, value in option_dict.items():
3179
 
            if isinstance(key, unicode):
3180
 
                key = key.encode('utf8')
3181
 
            if isinstance(value, unicode):
3182
 
                value = value.encode('utf8')
3183
 
            utf8_dict[key] = value
3184
 
        return bencode.bencode(utf8_dict)
3185
 
 
3186
 
    def _set_config_option_dict(self, value, name, section):
3187
 
        try:
3188
 
            path = self._branch._remote_path()
3189
 
            serialised_dict = self._serialize_option_dict(value)
3190
 
            response = self._branch._client.call(
3191
 
                'Branch.set_config_option_dict',
3192
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
3193
 
                serialised_dict, name, section or '')
3194
 
        except errors.UnknownSmartMethod:
3195
 
            medium = self._branch._client._medium
3196
 
            medium._remember_remote_is_before((2, 2))
3197
 
            return self._vfs_set_option(value, name, section)
3198
 
        if response != ():
3199
 
            raise errors.UnexpectedSmartServerResponse(response)
3200
 
 
3201
2471
    def _real_object(self):
3202
2472
        self._branch._ensure_real()
3203
2473
        return self._branch._real_branch
3290
2560
        raise NoSuchRevision(find('branch'), err.error_args[0])
3291
2561
    elif err.error_verb == 'nosuchrevision':
3292
2562
        raise NoSuchRevision(find('repository'), err.error_args[0])
3293
 
    elif err.error_verb == 'nobranch':
3294
 
        if len(err.error_args) >= 1:
3295
 
            extra = err.error_args[0]
3296
 
        else:
3297
 
            extra = None
3298
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3299
 
            detail=extra)
 
2563
    elif err.error_tuple == ('nobranch',):
 
2564
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
3300
2565
    elif err.error_verb == 'norepository':
3301
2566
        raise errors.NoRepositoryPresent(find('bzrdir'))
 
2567
    elif err.error_verb == 'LockContention':
 
2568
        raise errors.LockContention('(remote lock)')
3302
2569
    elif err.error_verb == 'UnlockableTransport':
3303
2570
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
 
2571
    elif err.error_verb == 'LockFailed':
 
2572
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3304
2573
    elif err.error_verb == 'TokenMismatch':
3305
2574
        raise errors.TokenMismatch(find('token'), '(remote token)')
3306
2575
    elif err.error_verb == 'Diverged':
3307
2576
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
 
2577
    elif err.error_verb == 'TipChangeRejected':
 
2578
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
2579
    elif err.error_verb == 'UnstackableBranchFormat':
 
2580
        raise errors.UnstackableBranchFormat(*err.error_args)
 
2581
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
2582
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3308
2583
    elif err.error_verb == 'NotStacked':
3309
2584
        raise errors.NotStacked(branch=find('branch'))
3310
2585
    elif err.error_verb == 'PermissionDenied':
3320
2595
    elif err.error_verb == 'NoSuchFile':
3321
2596
        path = get_path()
3322
2597
        raise errors.NoSuchFile(path)
3323
 
    _translate_error_without_context(err)
3324
 
 
3325
 
 
3326
 
def _translate_error_without_context(err):
3327
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3328
 
    if err.error_verb == 'IncompatibleRepositories':
3329
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3330
 
            err.error_args[1], err.error_args[2])
3331
 
    elif err.error_verb == 'LockContention':
3332
 
        raise errors.LockContention('(remote lock)')
3333
 
    elif err.error_verb == 'LockFailed':
3334
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3335
 
    elif err.error_verb == 'TipChangeRejected':
3336
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3337
 
    elif err.error_verb == 'UnstackableBranchFormat':
3338
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3339
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3340
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3341
2598
    elif err.error_verb == 'FileExists':
3342
2599
        raise errors.FileExists(err.error_args[0])
3343
2600
    elif err.error_verb == 'DirectoryNotEmpty':
3362
2619
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3363
2620
    elif err.error_verb == 'ReadOnlyError':
3364
2621
        raise errors.TransportNotPossible('readonly transport')
3365
 
    elif err.error_verb == 'MemoryError':
3366
 
        raise errors.BzrError("remote server out of memory\n"
3367
 
            "Retry non-remotely, or contact the server admin for details.")
3368
2622
    raise errors.UnknownErrorFromSmartServer(err)