← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(jam) Handle bug #382709 by encoding paths as 'mbcs' when spawning
        external diff.

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, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir as _mod_bzrdir,
 
22
    bzrdir,
23
23
    config,
24
 
    controldir,
25
24
    debug,
26
25
    errors,
27
26
    graph,
28
27
    lock,
29
28
    lockdir,
30
 
    repository as _mod_repository,
 
29
    repository,
 
30
    revision,
31
31
    revision as _mod_revision,
32
 
    static_tuple,
33
32
    symbol_versioning,
34
 
    urlutils,
35
 
    vf_repository,
36
 
    )
37
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
33
)
 
34
from bzrlib.branch import BranchReferenceFormat
 
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
36
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
37
from bzrlib.errors import (
40
38
    NoSuchRevision,
41
39
    SmartProtocolError,
42
40
    )
43
 
from bzrlib.i18n import gettext
44
41
from bzrlib.lockable_files import LockableFiles
45
42
from bzrlib.smart import client, vfs, repository as smart_repo
46
 
from bzrlib.smart.client import _SmartClient
47
 
from bzrlib.revision import NULL_REVISION
48
 
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
43
from bzrlib.revision import ensure_null, NULL_REVISION
49
44
from bzrlib.trace import mutter, note, warning
50
45
 
51
46
 
52
 
_DEFAULT_SEARCH_DEPTH = 100
53
 
 
54
 
 
55
47
class _RpcHelper(object):
56
48
    """Mixin class that helps with issuing RPCs."""
57
49
 
92
84
    return format
93
85
 
94
86
 
95
 
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
96
 
# does not have to be imported unless a remote format is involved.
97
 
 
98
 
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
99
 
    """Format representing bzrdirs accessed via a smart server"""
100
 
 
101
 
    supports_workingtrees = False
102
 
 
103
 
    def __init__(self):
104
 
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
105
 
        # XXX: It's a bit ugly that the network name is here, because we'd
106
 
        # like to believe that format objects are stateless or at least
107
 
        # immutable,  However, we do at least avoid mutating the name after
108
 
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
109
 
        self._network_name = None
110
 
 
111
 
    def __repr__(self):
112
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
113
 
            self._network_name)
114
 
 
115
 
    def get_format_description(self):
116
 
        if self._network_name:
117
 
            real_format = controldir.network_format_registry.get(self._network_name)
118
 
            return 'Remote: ' + real_format.get_format_description()
119
 
        return 'bzr remote bzrdir'
120
 
 
121
 
    def get_format_string(self):
122
 
        raise NotImplementedError(self.get_format_string)
123
 
 
124
 
    def network_name(self):
125
 
        if self._network_name:
126
 
            return self._network_name
127
 
        else:
128
 
            raise AssertionError("No network name set.")
129
 
 
130
 
    def initialize_on_transport(self, transport):
131
 
        try:
132
 
            # hand off the request to the smart server
133
 
            client_medium = transport.get_smart_medium()
134
 
        except errors.NoSmartMedium:
135
 
            # TODO: lookup the local format from a server hint.
136
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
137
 
            return local_dir_format.initialize_on_transport(transport)
138
 
        client = _SmartClient(client_medium)
139
 
        path = client.remote_path_from_transport(transport)
140
 
        try:
141
 
            response = client.call('BzrDirFormat.initialize', path)
142
 
        except errors.ErrorFromSmartServer, err:
143
 
            _translate_error(err, path=path)
144
 
        if response[0] != 'ok':
145
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
146
 
        format = RemoteBzrDirFormat()
147
 
        self._supply_sub_formats_to(format)
148
 
        return RemoteBzrDir(transport, format)
149
 
 
150
 
    def parse_NoneTrueFalse(self, arg):
151
 
        if not arg:
152
 
            return None
153
 
        if arg == 'False':
154
 
            return False
155
 
        if arg == 'True':
156
 
            return True
157
 
        raise AssertionError("invalid arg %r" % arg)
158
 
 
159
 
    def _serialize_NoneTrueFalse(self, arg):
160
 
        if arg is False:
161
 
            return 'False'
162
 
        if arg:
163
 
            return 'True'
164
 
        return ''
165
 
 
166
 
    def _serialize_NoneString(self, arg):
167
 
        return arg or ''
168
 
 
169
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
170
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
171
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
172
 
        shared_repo=False):
173
 
        try:
174
 
            # hand off the request to the smart server
175
 
            client_medium = transport.get_smart_medium()
176
 
        except errors.NoSmartMedium:
177
 
            do_vfs = True
178
 
        else:
179
 
            # Decline to open it if the server doesn't support our required
180
 
            # version (3) so that the VFS-based transport will do it.
181
 
            if client_medium.should_probe():
182
 
                try:
183
 
                    server_version = client_medium.protocol_version()
184
 
                    if server_version != '2':
185
 
                        do_vfs = True
186
 
                    else:
187
 
                        do_vfs = False
188
 
                except errors.SmartProtocolError:
189
 
                    # Apparently there's no usable smart server there, even though
190
 
                    # the medium supports the smart protocol.
191
 
                    do_vfs = True
192
 
            else:
193
 
                do_vfs = False
194
 
        if not do_vfs:
195
 
            client = _SmartClient(client_medium)
196
 
            path = client.remote_path_from_transport(transport)
197
 
            if client_medium._is_remote_before((1, 16)):
198
 
                do_vfs = True
199
 
        if do_vfs:
200
 
            # TODO: lookup the local format from a server hint.
201
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
202
 
            self._supply_sub_formats_to(local_dir_format)
203
 
            return local_dir_format.initialize_on_transport_ex(transport,
204
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
205
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
206
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
207
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
208
 
                vfs_only=True)
209
 
        return self._initialize_on_transport_ex_rpc(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
 
 
213
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
214
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
215
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
216
 
        args = []
217
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
218
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
219
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
220
 
        args.append(self._serialize_NoneString(stacked_on))
221
 
        # stack_on_pwd is often/usually our transport
222
 
        if stack_on_pwd:
223
 
            try:
224
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
225
 
                if not stack_on_pwd:
226
 
                    stack_on_pwd = '.'
227
 
            except errors.PathNotChild:
228
 
                pass
229
 
        args.append(self._serialize_NoneString(stack_on_pwd))
230
 
        args.append(self._serialize_NoneString(repo_format_name))
231
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
232
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
233
 
        request_network_name = self._network_name or \
234
 
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
235
 
        try:
236
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
237
 
                request_network_name, path, *args)
238
 
        except errors.UnknownSmartMethod:
239
 
            client._medium._remember_remote_is_before((1,16))
240
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
241
 
            self._supply_sub_formats_to(local_dir_format)
242
 
            return local_dir_format.initialize_on_transport_ex(transport,
243
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
244
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
245
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
246
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
247
 
                vfs_only=True)
248
 
        except errors.ErrorFromSmartServer, err:
249
 
            _translate_error(err, path=path)
250
 
        repo_path = response[0]
251
 
        bzrdir_name = response[6]
252
 
        require_stacking = response[7]
253
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
254
 
        format = RemoteBzrDirFormat()
255
 
        format._network_name = bzrdir_name
256
 
        self._supply_sub_formats_to(format)
257
 
        bzrdir = RemoteBzrDir(transport, format, _client=client)
258
 
        if repo_path:
259
 
            repo_format = response_tuple_to_repo_format(response[1:])
260
 
            if repo_path == '.':
261
 
                repo_path = ''
262
 
            if repo_path:
263
 
                repo_bzrdir_format = RemoteBzrDirFormat()
264
 
                repo_bzrdir_format._network_name = response[5]
265
 
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
266
 
                    repo_bzrdir_format)
267
 
            else:
268
 
                repo_bzr = bzrdir
269
 
            final_stack = response[8] or None
270
 
            final_stack_pwd = response[9] or None
271
 
            if final_stack_pwd:
272
 
                final_stack_pwd = urlutils.join(
273
 
                    transport.base, final_stack_pwd)
274
 
            remote_repo = RemoteRepository(repo_bzr, repo_format)
275
 
            if len(response) > 10:
276
 
                # Updated server verb that locks remotely.
277
 
                repo_lock_token = response[10] or None
278
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
279
 
                if repo_lock_token:
280
 
                    remote_repo.dont_leave_lock_in_place()
281
 
            else:
282
 
                remote_repo.lock_write()
283
 
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
284
 
                final_stack_pwd, require_stacking)
285
 
            policy.acquire_repository()
286
 
        else:
287
 
            remote_repo = None
288
 
            policy = None
289
 
        bzrdir._format.set_branch_format(self.get_branch_format())
290
 
        if require_stacking:
291
 
            # The repo has already been created, but we need to make sure that
292
 
            # we'll make a stackable branch.
293
 
            bzrdir._format.require_stacking(_skip_repo=True)
294
 
        return remote_repo, bzrdir, require_stacking, policy
295
 
 
296
 
    def _open(self, transport):
297
 
        return RemoteBzrDir(transport, self)
298
 
 
299
 
    def __eq__(self, other):
300
 
        if not isinstance(other, RemoteBzrDirFormat):
301
 
            return False
302
 
        return self.get_format_description() == other.get_format_description()
303
 
 
304
 
    def __return_repository_format(self):
305
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
306
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
307
 
        # that it should use that for init() etc.
308
 
        result = RemoteRepositoryFormat()
309
 
        custom_format = getattr(self, '_repository_format', None)
310
 
        if custom_format:
311
 
            if isinstance(custom_format, RemoteRepositoryFormat):
312
 
                return custom_format
313
 
            else:
314
 
                # We will use the custom format to create repositories over the
315
 
                # wire; expose its details like rich_root_data for code to
316
 
                # query
317
 
                result._custom_format = custom_format
318
 
        return result
319
 
 
320
 
    def get_branch_format(self):
321
 
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
322
 
        if not isinstance(result, RemoteBranchFormat):
323
 
            new_result = RemoteBranchFormat()
324
 
            new_result._custom_format = result
325
 
            # cache the result
326
 
            self.set_branch_format(new_result)
327
 
            result = new_result
328
 
        return result
329
 
 
330
 
    repository_format = property(__return_repository_format,
331
 
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
332
 
 
333
 
 
334
 
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
 
87
# Note: RemoteBzrDirFormat is in bzrdir.py
 
88
 
 
89
class RemoteBzrDir(BzrDir, _RpcHelper):
335
90
    """Control directory on a remote server, accessed via bzr:// or similar."""
336
91
 
337
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
92
    def __init__(self, transport, format, _client=None):
338
93
        """Construct a RemoteBzrDir.
339
94
 
340
95
        :param _client: Private parameter for testing. Disables probing and the
341
96
            use of a real bzrdir.
342
97
        """
343
 
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
 
98
        BzrDir.__init__(self, transport, format)
344
99
        # this object holds a delegated bzrdir that uses file-level operations
345
100
        # to talk to the other side
346
101
        self._real_bzrdir = None
347
 
        self._has_working_tree = None
348
102
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
349
103
        # create_branch for details.
350
104
        self._next_open_branch_result = None
354
108
            self._client = client._SmartClient(medium)
355
109
        else:
356
110
            self._client = _client
357
 
            if not _force_probe:
358
 
                return
359
 
 
360
 
        self._probe_bzrdir()
361
 
 
362
 
    def __repr__(self):
363
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
364
 
 
365
 
    def _probe_bzrdir(self):
366
 
        medium = self._client._medium
 
111
            return
 
112
 
367
113
        path = self._path_for_remote_call(self._client)
368
 
        if medium._is_remote_before((2, 1)):
369
 
            self._rpc_open(path)
370
 
            return
371
 
        try:
372
 
            self._rpc_open_2_1(path)
373
 
            return
374
 
        except errors.UnknownSmartMethod:
375
 
            medium._remember_remote_is_before((2, 1))
376
 
            self._rpc_open(path)
377
 
 
378
 
    def _rpc_open_2_1(self, path):
379
 
        response = self._call('BzrDir.open_2.1', path)
380
 
        if response == ('no',):
381
 
            raise errors.NotBranchError(path=self.root_transport.base)
382
 
        elif response[0] == 'yes':
383
 
            if response[1] == 'yes':
384
 
                self._has_working_tree = True
385
 
            elif response[1] == 'no':
386
 
                self._has_working_tree = False
387
 
            else:
388
 
                raise errors.UnexpectedSmartServerResponse(response)
389
 
        else:
390
 
            raise errors.UnexpectedSmartServerResponse(response)
391
 
 
392
 
    def _rpc_open(self, path):
393
114
        response = self._call('BzrDir.open', path)
394
115
        if response not in [('yes',), ('no',)]:
395
116
            raise errors.UnexpectedSmartServerResponse(response)
396
117
        if response == ('no',):
397
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
118
            raise errors.NotBranchError(path=transport.base)
398
119
 
399
120
    def _ensure_real(self):
400
121
        """Ensure that there is a _real_bzrdir set.
402
123
        Used before calls to self._real_bzrdir.
403
124
        """
404
125
        if not self._real_bzrdir:
405
 
            if 'hpssvfs' in debug.debug_flags:
406
 
                import traceback
407
 
                warning('VFS BzrDir access triggered\n%s',
408
 
                    ''.join(traceback.format_stack()))
409
 
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
126
            self._real_bzrdir = BzrDir.open_from_transport(
410
127
                self.root_transport, _server_formats=False)
411
128
            self._format._network_name = \
412
129
                self._real_bzrdir._format.network_name()
418
135
        # Prevent aliasing problems in the next_open_branch_result cache.
419
136
        # See create_branch for rationale.
420
137
        self._next_open_branch_result = None
421
 
        return _mod_bzrdir.BzrDir.break_lock(self)
 
138
        return BzrDir.break_lock(self)
422
139
 
423
140
    def _vfs_cloning_metadir(self, require_stacking=False):
424
141
        self._ensure_real()
455
172
        if len(branch_info) != 2:
456
173
            raise errors.UnexpectedSmartServerResponse(response)
457
174
        branch_ref, branch_name = branch_info
458
 
        format = controldir.network_format_registry.get(control_name)
 
175
        format = bzrdir.network_format_registry.get(control_name)
459
176
        if repo_name:
460
 
            format.repository_format = _mod_repository.network_format_registry.get(
 
177
            format.repository_format = repository.network_format_registry.get(
461
178
                repo_name)
462
179
        if branch_ref == 'ref':
463
180
            # XXX: we need possible_transports here to avoid reopening the
464
181
            # connection to the referenced location
465
 
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
 
182
            ref_bzrdir = BzrDir.open(branch_name)
466
183
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
467
184
            format.set_branch_format(branch_format)
468
185
        elif branch_ref == 'branch':
487
204
        self._ensure_real()
488
205
        self._real_bzrdir.destroy_repository()
489
206
 
490
 
    def create_branch(self, name=None, repository=None,
491
 
                      append_revisions_only=None):
 
207
    def create_branch(self):
492
208
        # as per meta1 formats - just delegate to the format object which may
493
209
        # be parameterised.
494
 
        real_branch = self._format.get_branch_format().initialize(self,
495
 
            name=name, repository=repository,
496
 
            append_revisions_only=append_revisions_only)
 
210
        real_branch = self._format.get_branch_format().initialize(self)
497
211
        if not isinstance(real_branch, RemoteBranch):
498
 
            if not isinstance(repository, RemoteRepository):
499
 
                raise AssertionError(
500
 
                    'need a RemoteRepository to use with RemoteBranch, got %r'
501
 
                    % (repository,))
502
 
            result = RemoteBranch(self, repository, real_branch, name=name)
 
212
            result = RemoteBranch(self, self.find_repository(), real_branch)
503
213
        else:
504
214
            result = real_branch
505
215
        # BzrDir.clone_on_transport() uses the result of create_branch but does
511
221
        self._next_open_branch_result = result
512
222
        return result
513
223
 
514
 
    def destroy_branch(self, name=None):
 
224
    def destroy_branch(self):
515
225
        """See BzrDir.destroy_branch"""
516
226
        self._ensure_real()
517
 
        self._real_bzrdir.destroy_branch(name=name)
 
227
        self._real_bzrdir.destroy_branch()
518
228
        self._next_open_branch_result = None
519
229
 
520
 
    def create_workingtree(self, revision_id=None, from_branch=None,
521
 
        accelerator_tree=None, hardlink=False):
 
230
    def create_workingtree(self, revision_id=None, from_branch=None):
522
231
        raise errors.NotLocalUrl(self.transport.base)
523
232
 
524
 
    def find_branch_format(self, name=None):
 
233
    def find_branch_format(self):
525
234
        """Find the branch 'format' for this bzrdir.
526
235
 
527
236
        This might be a synthetic object for e.g. RemoteBranch and SVN.
528
237
        """
529
 
        b = self.open_branch(name=name)
 
238
        b = self.open_branch()
530
239
        return b._format
531
240
 
532
 
    def get_branch_reference(self, name=None):
 
241
    def get_branch_reference(self):
533
242
        """See BzrDir.get_branch_reference()."""
534
 
        if name is not None:
535
 
            # XXX JRV20100304: Support opening colocated branches
536
 
            raise errors.NoColocatedBranchSupport(self)
537
243
        response = self._get_branch_reference()
538
244
        if response[0] == 'ref':
539
245
            return response[1]
543
249
    def _get_branch_reference(self):
544
250
        path = self._path_for_remote_call(self._client)
545
251
        medium = self._client._medium
546
 
        candidate_calls = [
547
 
            ('BzrDir.open_branchV3', (2, 1)),
548
 
            ('BzrDir.open_branchV2', (1, 13)),
549
 
            ('BzrDir.open_branch', None),
550
 
            ]
551
 
        for verb, required_version in candidate_calls:
552
 
            if required_version and medium._is_remote_before(required_version):
553
 
                continue
 
252
        if not medium._is_remote_before((1, 13)):
554
253
            try:
555
 
                response = self._call(verb, path)
 
254
                response = self._call('BzrDir.open_branchV2', path)
 
255
                if response[0] not in ('ref', 'branch'):
 
256
                    raise errors.UnexpectedSmartServerResponse(response)
 
257
                return response
556
258
            except errors.UnknownSmartMethod:
557
 
                if required_version is None:
558
 
                    raise
559
 
                medium._remember_remote_is_before(required_version)
560
 
            else:
561
 
                break
562
 
        if verb == 'BzrDir.open_branch':
563
 
            if response[0] != 'ok':
564
 
                raise errors.UnexpectedSmartServerResponse(response)
565
 
            if response[1] != '':
566
 
                return ('ref', response[1])
567
 
            else:
568
 
                return ('branch', '')
569
 
        if response[0] not in ('ref', 'branch'):
 
259
                medium._remember_remote_is_before((1, 13))
 
260
        response = self._call('BzrDir.open_branch', path)
 
261
        if response[0] != 'ok':
570
262
            raise errors.UnexpectedSmartServerResponse(response)
571
 
        return response
 
263
        if response[1] != '':
 
264
            return ('ref', response[1])
 
265
        else:
 
266
            return ('branch', '')
572
267
 
573
 
    def _get_tree_branch(self, name=None):
 
268
    def _get_tree_branch(self):
574
269
        """See BzrDir._get_tree_branch()."""
575
 
        return None, self.open_branch(name=name)
 
270
        return None, self.open_branch()
576
271
 
577
 
    def open_branch(self, name=None, unsupported=False,
578
 
                    ignore_fallbacks=False):
579
 
        if unsupported:
 
272
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
273
        if _unsupported:
580
274
            raise NotImplementedError('unsupported flag support not implemented yet.')
581
275
        if self._next_open_branch_result is not None:
582
276
            # See create_branch for details.
587
281
        if response[0] == 'ref':
588
282
            # a branch reference, use the existing BranchReference logic.
589
283
            format = BranchReferenceFormat()
590
 
            return format.open(self, name=name, _found=True,
591
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
284
            return format.open(self, _found=True, location=response[1],
 
285
                ignore_fallbacks=ignore_fallbacks)
592
286
        branch_format_name = response[1]
593
287
        if not branch_format_name:
594
288
            branch_format_name = None
595
289
        format = RemoteBranchFormat(network_name=branch_format_name)
596
290
        return RemoteBranch(self, self.find_repository(), format=format,
597
 
            setup_stacking=not ignore_fallbacks, name=name)
 
291
            setup_stacking=not ignore_fallbacks)
598
292
 
599
293
    def _open_repo_v1(self, path):
600
294
        verb = 'BzrDir.find_repository'
661
355
        else:
662
356
            raise errors.NoRepositoryPresent(self)
663
357
 
664
 
    def has_workingtree(self):
665
 
        if self._has_working_tree is None:
666
 
            self._ensure_real()
667
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
668
 
        return self._has_working_tree
669
 
 
670
358
    def open_workingtree(self, recommend_upgrade=True):
671
 
        if self.has_workingtree():
 
359
        self._ensure_real()
 
360
        if self._real_bzrdir.has_workingtree():
672
361
            raise errors.NotLocalUrl(self.root_transport)
673
362
        else:
674
363
            raise errors.NoWorkingTree(self.root_transport.base)
675
364
 
676
365
    def _path_for_remote_call(self, client):
677
366
        """Return the path to be used for this bzrdir in a remote call."""
678
 
        return urlutils.split_segment_parameters_raw(
679
 
            client.remote_path_from_transport(self.root_transport))[0]
 
367
        return client.remote_path_from_transport(self.root_transport)
680
368
 
681
 
    def get_branch_transport(self, branch_format, name=None):
 
369
    def get_branch_transport(self, branch_format):
682
370
        self._ensure_real()
683
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
371
        return self._real_bzrdir.get_branch_transport(branch_format)
684
372
 
685
373
    def get_repository_transport(self, repository_format):
686
374
        self._ensure_real()
694
382
        """Upgrading of remote bzrdirs is not supported yet."""
695
383
        return False
696
384
 
697
 
    def needs_format_conversion(self, format):
 
385
    def needs_format_conversion(self, format=None):
698
386
        """Upgrading of remote bzrdirs is not supported yet."""
 
387
        if format is None:
 
388
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
389
                % 'needs_format_conversion(format=None)')
699
390
        return False
700
391
 
701
392
    def clone(self, url, revision_id=None, force_new_repo=False,
708
399
        return RemoteBzrDirConfig(self)
709
400
 
710
401
 
711
 
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
 
402
class RemoteRepositoryFormat(repository.RepositoryFormat):
712
403
    """Format for repositories accessed over a _SmartClient.
713
404
 
714
405
    Instances of this repository are represented by RemoteRepository
729
420
    """
730
421
 
731
422
    _matchingbzrdir = RemoteBzrDirFormat()
732
 
    supports_full_versioned_files = True
733
 
    supports_leaving_lock = True
734
423
 
735
424
    def __init__(self):
736
 
        _mod_repository.RepositoryFormat.__init__(self)
 
425
        repository.RepositoryFormat.__init__(self)
737
426
        self._custom_format = None
738
427
        self._network_name = None
739
428
        self._creating_bzrdir = None
740
 
        self._revision_graph_can_have_wrong_parents = None
741
 
        self._supports_chks = None
742
429
        self._supports_external_lookups = None
743
430
        self._supports_tree_reference = None
744
 
        self._supports_funky_characters = None
745
 
        self._supports_nesting_repositories = None
746
431
        self._rich_root_data = None
747
432
 
748
 
    def __repr__(self):
749
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
750
 
            self._network_name)
751
 
 
752
433
    @property
753
434
    def fast_deltas(self):
754
435
        self._ensure_real()
762
443
        return self._rich_root_data
763
444
 
764
445
    @property
765
 
    def supports_chks(self):
766
 
        if self._supports_chks is None:
767
 
            self._ensure_real()
768
 
            self._supports_chks = self._custom_format.supports_chks
769
 
        return self._supports_chks
770
 
 
771
 
    @property
772
446
    def supports_external_lookups(self):
773
447
        if self._supports_external_lookups is None:
774
448
            self._ensure_real()
777
451
        return self._supports_external_lookups
778
452
 
779
453
    @property
780
 
    def supports_funky_characters(self):
781
 
        if self._supports_funky_characters is None:
782
 
            self._ensure_real()
783
 
            self._supports_funky_characters = \
784
 
                self._custom_format.supports_funky_characters
785
 
        return self._supports_funky_characters
786
 
 
787
 
    @property
788
 
    def supports_nesting_repositories(self):
789
 
        if self._supports_nesting_repositories is None:
790
 
            self._ensure_real()
791
 
            self._supports_nesting_repositories = \
792
 
                self._custom_format.supports_nesting_repositories
793
 
        return self._supports_nesting_repositories
794
 
 
795
 
    @property
796
454
    def supports_tree_reference(self):
797
455
        if self._supports_tree_reference is None:
798
456
            self._ensure_real()
800
458
                self._custom_format.supports_tree_reference
801
459
        return self._supports_tree_reference
802
460
 
803
 
    @property
804
 
    def revision_graph_can_have_wrong_parents(self):
805
 
        if self._revision_graph_can_have_wrong_parents is None:
806
 
            self._ensure_real()
807
 
            self._revision_graph_can_have_wrong_parents = \
808
 
                self._custom_format.revision_graph_can_have_wrong_parents
809
 
        return self._revision_graph_can_have_wrong_parents
810
 
 
811
461
    def _vfs_initialize(self, a_bzrdir, shared):
812
462
        """Helper for common code in initialize."""
813
463
        if self._custom_format:
848
498
            network_name = self._network_name
849
499
        else:
850
500
            # Select the current bzrlib default and ask for that.
851
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
501
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
852
502
            reference_format = reference_bzrdir_format.repository_format
853
503
            network_name = reference_format.network_name()
854
504
        # 2) try direct creation via RPC
880
530
 
881
531
    def _ensure_real(self):
882
532
        if self._custom_format is None:
883
 
            self._custom_format = _mod_repository.network_format_registry.get(
 
533
            self._custom_format = repository.network_format_registry.get(
884
534
                self._network_name)
885
535
 
886
536
    @property
899
549
        return self._custom_format._fetch_reconcile
900
550
 
901
551
    def get_format_description(self):
902
 
        self._ensure_real()
903
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
552
        return 'bzr remote repository'
904
553
 
905
554
    def __eq__(self, other):
906
555
        return self.__class__ is other.__class__
907
556
 
 
557
    def check_conversion_target(self, target_format):
 
558
        if self.rich_root_data and not target_format.rich_root_data:
 
559
            raise errors.BadConversionTarget(
 
560
                'Does not support rich root data.', target_format)
 
561
        if (self.supports_tree_reference and
 
562
            not getattr(target_format, 'supports_tree_reference', False)):
 
563
            raise errors.BadConversionTarget(
 
564
                'Does not support nested trees', target_format)
 
565
 
908
566
    def network_name(self):
909
567
        if self._network_name:
910
568
            return self._network_name
922
580
        return self._custom_format._serializer
923
581
 
924
582
 
925
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
926
 
    controldir.ControlComponent):
 
583
class RemoteRepository(_RpcHelper):
927
584
    """Repository accessed over rpc.
928
585
 
929
586
    For the moment most operations are performed using local transport-backed
972
629
        # Additional places to query for data.
973
630
        self._fallback_repositories = []
974
631
 
975
 
    @property
976
 
    def user_transport(self):
977
 
        return self.bzrdir.user_transport
978
 
 
979
 
    @property
980
 
    def control_transport(self):
981
 
        # XXX: Normally you shouldn't directly get at the remote repository
982
 
        # transport, but I'm not sure it's worth making this method
983
 
        # optional -- mbp 2010-04-21
984
 
        return self.bzrdir.get_repository_transport(None)
985
 
 
986
632
    def __str__(self):
987
633
        return "%s(%s)" % (self.__class__.__name__, self.base)
988
634
 
1096
742
    def find_text_key_references(self):
1097
743
        """Find the text key references within the repository.
1098
744
 
 
745
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
746
        revision_ids. Each altered file-ids has the exact revision_ids that
 
747
        altered it listed explicitly.
1099
748
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1100
749
            to whether they were referred to by the inventory of the
1101
750
            revision_id that they contain. The inventory texts from all present
1119
768
        """Private method for using with old (< 1.2) servers to fallback."""
1120
769
        if revision_id is None:
1121
770
            revision_id = ''
1122
 
        elif _mod_revision.is_null(revision_id):
 
771
        elif revision.is_null(revision_id):
1123
772
            return {}
1124
773
 
1125
774
        path = self.bzrdir._path_for_remote_call(self._client)
1149
798
        return RemoteStreamSource(self, to_format)
1150
799
 
1151
800
    @needs_read_lock
1152
 
    def get_file_graph(self):
1153
 
        return graph.Graph(self.texts)
1154
 
 
1155
 
    @needs_read_lock
1156
801
    def has_revision(self, revision_id):
1157
802
        """True if this repository has a copy of the revision."""
1158
803
        # Copy of bzrlib.repository.Repository.has_revision
1175
820
    def _has_same_fallbacks(self, other_repo):
1176
821
        """Returns true if the repositories have the same fallbacks."""
1177
822
        # XXX: copied from Repository; it should be unified into a base class
1178
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
823
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
1179
824
        my_fb = self._fallback_repositories
1180
825
        other_fb = other_repo._fallback_repositories
1181
826
        if len(my_fb) != len(other_fb):
1197
842
        parents_provider = self._make_parents_provider(other_repository)
1198
843
        return graph.Graph(parents_provider)
1199
844
 
1200
 
    @needs_read_lock
1201
 
    def get_known_graph_ancestry(self, revision_ids):
1202
 
        """Return the known graph for a set of revision ids and their ancestors.
1203
 
        """
1204
 
        st = static_tuple.StaticTuple
1205
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
1206
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
1207
 
        return graph.GraphThunkIdsToKeys(known_graph)
1208
 
 
1209
845
    def gather_stats(self, revid=None, committers=None):
1210
846
        """See Repository.gather_stats()."""
1211
847
        path = self.bzrdir._path_for_remote_call(self._client)
1212
848
        # revid can be None to indicate no revisions, not just NULL_REVISION
1213
 
        if revid is None or _mod_revision.is_null(revid):
 
849
        if revid is None or revision.is_null(revid):
1214
850
            fmt_revid = ''
1215
851
        else:
1216
852
            fmt_revid = revid
1271
907
    def is_write_locked(self):
1272
908
        return self._lock_mode == 'w'
1273
909
 
1274
 
    def _warn_if_deprecated(self, branch=None):
1275
 
        # If we have a real repository, the check will be done there, if we
1276
 
        # don't the check will be done remotely.
1277
 
        pass
1278
 
 
1279
910
    def lock_read(self):
1280
 
        """Lock the repository for read operations.
1281
 
 
1282
 
        :return: A bzrlib.lock.LogicalLockResult.
1283
 
        """
1284
911
        # wrong eventually - want a local lock cache context
1285
912
        if not self._lock_mode:
1286
 
            self._note_lock('r')
1287
913
            self._lock_mode = 'r'
1288
914
            self._lock_count = 1
1289
915
            self._unstacked_provider.enable_cache(cache_misses=True)
1293
919
                repo.lock_read()
1294
920
        else:
1295
921
            self._lock_count += 1
1296
 
        return lock.LogicalLockResult(self.unlock)
1297
922
 
1298
923
    def _remote_lock_write(self, token):
1299
924
        path = self.bzrdir._path_for_remote_call(self._client)
1310
935
 
1311
936
    def lock_write(self, token=None, _skip_rpc=False):
1312
937
        if not self._lock_mode:
1313
 
            self._note_lock('w')
1314
938
            if _skip_rpc:
1315
939
                if self._lock_token is not None:
1316
940
                    if token != self._lock_token:
1339
963
            raise errors.ReadOnlyError(self)
1340
964
        else:
1341
965
            self._lock_count += 1
1342
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
966
        return self._lock_token or None
1343
967
 
1344
968
    def leave_lock_in_place(self):
1345
969
        if not self._lock_token:
1419
1043
        else:
1420
1044
            raise errors.UnexpectedSmartServerResponse(response)
1421
1045
 
1422
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1423
1046
    def unlock(self):
1424
1047
        if not self._lock_count:
1425
1048
            return lock.cant_unlock_not_held(self)
1499
1122
 
1500
1123
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1501
1124
                           timezone=None, committer=None, revprops=None,
1502
 
                           revision_id=None, lossy=False):
 
1125
                           revision_id=None):
1503
1126
        # FIXME: It ought to be possible to call this without immediately
1504
1127
        # triggering _ensure_real.  For now it's the easiest thing to do.
1505
1128
        self._ensure_real()
1506
1129
        real_repo = self._real_repository
1507
1130
        builder = real_repo.get_commit_builder(branch, parents,
1508
1131
                config, timestamp=timestamp, timezone=timezone,
1509
 
                committer=committer, revprops=revprops,
1510
 
                revision_id=revision_id, lossy=lossy)
 
1132
                committer=committer, revprops=revprops, revision_id=revision_id)
1511
1133
        return builder
1512
1134
 
1513
1135
    def add_fallback_repository(self, repository):
1521
1143
        # We need to accumulate additional repositories here, to pass them in
1522
1144
        # on various RPC's.
1523
1145
        #
1524
 
        # Make the check before we lock: this raises an exception.
1525
 
        self._check_fallback_repository(repository)
1526
1146
        if self.is_locked():
1527
1147
            # We will call fallback.unlock() when we transition to the unlocked
1528
1148
            # state, so always add a lock here. If a caller passes us a locked
1533
1153
        # _real_branch had its get_stacked_on_url method called), then the
1534
1154
        # repository to be added may already be in the _real_repositories list.
1535
1155
        if self._real_repository is not None:
1536
 
            fallback_locations = [repo.user_url for repo in
 
1156
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1537
1157
                self._real_repository._fallback_repositories]
1538
 
            if repository.user_url not in fallback_locations:
 
1158
            if repository.bzrdir.root_transport.base not in fallback_locations:
1539
1159
                self._real_repository.add_fallback_repository(repository)
1540
1160
 
1541
 
    def _check_fallback_repository(self, repository):
1542
 
        """Check that this repository can fallback to repository safely.
1543
 
 
1544
 
        Raise an error if not.
1545
 
 
1546
 
        :param repository: A repository to fallback to.
1547
 
        """
1548
 
        return _mod_repository.InterRepository._assert_same_model(
1549
 
            self, repository)
1550
 
 
1551
1161
    def add_inventory(self, revid, inv, parents):
1552
1162
        self._ensure_real()
1553
1163
        return self._real_repository.add_inventory(revid, inv, parents)
1554
1164
 
1555
1165
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1556
 
            parents, basis_inv=None, propagate_caches=False):
 
1166
                               parents):
1557
1167
        self._ensure_real()
1558
1168
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1559
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1560
 
            propagate_caches=propagate_caches)
 
1169
            delta, new_revision_id, parents)
1561
1170
 
1562
1171
    def add_revision(self, rev_id, rev, inv=None, config=None):
1563
1172
        self._ensure_real()
1569
1178
        self._ensure_real()
1570
1179
        return self._real_repository.get_inventory(revision_id)
1571
1180
 
1572
 
    def iter_inventories(self, revision_ids, ordering=None):
 
1181
    def iter_inventories(self, revision_ids):
1573
1182
        self._ensure_real()
1574
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1183
        return self._real_repository.iter_inventories(revision_ids)
1575
1184
 
1576
1185
    @needs_read_lock
1577
1186
    def get_revision(self, revision_id):
1593
1202
        return self._real_repository.make_working_trees()
1594
1203
 
1595
1204
    def refresh_data(self):
1596
 
        """Re-read any data needed to synchronise with disk.
 
1205
        """Re-read any data needed to to synchronise with disk.
1597
1206
 
1598
1207
        This method is intended to be called after another repository instance
1599
1208
        (such as one used by a smart server) has inserted data into the
1600
 
        repository. On all repositories this will work outside of write groups.
1601
 
        Some repository formats (pack and newer for bzrlib native formats)
1602
 
        support refresh_data inside write groups. If called inside a write
1603
 
        group on a repository that does not support refreshing in a write group
1604
 
        IsInWriteGroupError will be raised.
 
1209
        repository. It may not be called during a write group, but may be
 
1210
        called at any other time.
1605
1211
        """
 
1212
        if self.is_in_write_group():
 
1213
            raise errors.InternalBzrError(
 
1214
                "May not refresh_data while in a write group.")
1606
1215
        if self._real_repository is not None:
1607
1216
            self._real_repository.refresh_data()
1608
1217
 
1620
1229
        return result
1621
1230
 
1622
1231
    @needs_read_lock
1623
 
    def search_missing_revision_ids(self, other,
1624
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1625
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1626
 
            limit=None):
 
1232
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1627
1233
        """Return the revision ids that other has that this does not.
1628
1234
 
1629
1235
        These are returned in topological order.
1630
1236
 
1631
1237
        revision_id: only return revision ids included by revision_id.
1632
1238
        """
1633
 
        if symbol_versioning.deprecated_passed(revision_id):
1634
 
            symbol_versioning.warn(
1635
 
                'search_missing_revision_ids(revision_id=...) was '
1636
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
1637
 
                DeprecationWarning, stacklevel=2)
1638
 
            if revision_ids is not None:
1639
 
                raise AssertionError(
1640
 
                    'revision_ids is mutually exclusive with revision_id')
1641
 
            if revision_id is not None:
1642
 
                revision_ids = [revision_id]
1643
 
        inter_repo = _mod_repository.InterRepository.get(other, self)
1644
 
        return inter_repo.search_missing_revision_ids(
1645
 
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1646
 
            if_present_ids=if_present_ids, limit=limit)
 
1239
        return repository.InterRepository.get(
 
1240
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
1647
1241
 
1648
 
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
1242
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1649
1243
            fetch_spec=None):
1650
1244
        # No base implementation to use as RemoteRepository is not a subclass
1651
1245
        # of Repository; so this is a copy of Repository.fetch().
1662
1256
            # check that last_revision is in 'from' and then return a
1663
1257
            # no-operation.
1664
1258
            if (revision_id is not None and
1665
 
                not _mod_revision.is_null(revision_id)):
 
1259
                not revision.is_null(revision_id)):
1666
1260
                self.get_revision(revision_id)
1667
1261
            return 0, []
1668
1262
        # if there is no specific appropriate InterRepository, this will get
1669
1263
        # the InterRepository base class, which raises an
1670
1264
        # IncompatibleRepositories when asked to fetch.
1671
 
        inter = _mod_repository.InterRepository.get(source, self)
1672
 
        return inter.fetch(revision_id=revision_id,
 
1265
        inter = repository.InterRepository.get(source, self)
 
1266
        return inter.fetch(revision_id=revision_id, pb=pb,
1673
1267
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1674
1268
 
1675
1269
    def create_bundle(self, target, base, fileobj, format=None):
1677
1271
        self._real_repository.create_bundle(target, base, fileobj, format)
1678
1272
 
1679
1273
    @needs_read_lock
1680
 
    @symbol_versioning.deprecated_method(
1681
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1682
1274
    def get_ancestry(self, revision_id, topo_sorted=True):
1683
1275
        self._ensure_real()
1684
1276
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1698
1290
        self._ensure_real()
1699
1291
        return self._real_repository.iter_files_bytes(desired_files)
1700
1292
 
1701
 
    def get_cached_parent_map(self, revision_ids):
1702
 
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
1703
 
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1704
 
 
1705
1293
    def get_parent_map(self, revision_ids):
1706
1294
        """See bzrlib.Graph.get_parent_map()."""
1707
1295
        return self._make_parents_provider().get_parent_map(revision_ids)
1765
1353
        if parents_map is None:
1766
1354
            # Repository is not locked, so there's no cache.
1767
1355
            parents_map = {}
1768
 
        if _DEFAULT_SEARCH_DEPTH <= 0:
1769
 
            (start_set, stop_keys,
1770
 
             key_count) = graph.search_result_from_parent_map(
1771
 
                parents_map, self._unstacked_provider.missing_keys)
1772
 
        else:
1773
 
            (start_set, stop_keys,
1774
 
             key_count) = graph.limited_search_result_from_parent_map(
1775
 
                parents_map, self._unstacked_provider.missing_keys,
1776
 
                keys, depth=_DEFAULT_SEARCH_DEPTH)
 
1356
        # start_set is all the keys in the cache
 
1357
        start_set = set(parents_map)
 
1358
        # result set is all the references to keys in the cache
 
1359
        result_parents = set()
 
1360
        for parents in parents_map.itervalues():
 
1361
            result_parents.update(parents)
 
1362
        stop_keys = result_parents.difference(start_set)
 
1363
        # We don't need to send ghosts back to the server as a position to
 
1364
        # stop either.
 
1365
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
 
1366
        key_count = len(parents_map)
 
1367
        if (NULL_REVISION in result_parents
 
1368
            and NULL_REVISION in self._unstacked_provider.missing_keys):
 
1369
            # If we pruned NULL_REVISION from the stop_keys because it's also
 
1370
            # in our cache of "missing" keys we need to increment our key count
 
1371
            # by 1, because the reconsitituted SearchResult on the server will
 
1372
            # still consider NULL_REVISION to be an included key.
 
1373
            key_count += 1
 
1374
        included_keys = start_set.intersection(result_parents)
 
1375
        start_set.difference_update(included_keys)
1777
1376
        recipe = ('manual', start_set, stop_keys, key_count)
1778
1377
        body = self._serialise_search_recipe(recipe)
1779
1378
        path = self.bzrdir._path_for_remote_call(self._client)
1832
1431
        return self._real_repository.get_signature_text(revision_id)
1833
1432
 
1834
1433
    @needs_read_lock
1835
 
    def _get_inventory_xml(self, revision_id):
1836
 
        self._ensure_real()
1837
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1434
    def get_inventory_xml(self, revision_id):
 
1435
        self._ensure_real()
 
1436
        return self._real_repository.get_inventory_xml(revision_id)
 
1437
 
 
1438
    def deserialise_inventory(self, revision_id, xml):
 
1439
        self._ensure_real()
 
1440
        return self._real_repository.deserialise_inventory(revision_id, xml)
1838
1441
 
1839
1442
    def reconcile(self, other=None, thorough=False):
1840
1443
        self._ensure_real()
1867
1470
        return self._real_repository.get_revision_reconcile(revision_id)
1868
1471
 
1869
1472
    @needs_read_lock
1870
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1473
    def check(self, revision_ids=None):
1871
1474
        self._ensure_real()
1872
 
        return self._real_repository.check(revision_ids=revision_ids,
1873
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1475
        return self._real_repository.check(revision_ids=revision_ids)
1874
1476
 
1875
1477
    def copy_content_into(self, destination, revision_id=None):
1876
1478
        self._ensure_real()
1883
1485
        from bzrlib import osutils
1884
1486
        import tarfile
1885
1487
        # TODO: Maybe a progress bar while streaming the tarball?
1886
 
        note(gettext("Copying repository content as tarball..."))
 
1488
        note("Copying repository content as tarball...")
1887
1489
        tar_file = self._get_tarball('bz2')
1888
1490
        if tar_file is None:
1889
1491
            return None
1894
1496
            tmpdir = osutils.mkdtemp()
1895
1497
            try:
1896
1498
                _extract_tar(tar, tmpdir)
1897
 
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
 
1499
                tmp_bzrdir = BzrDir.open(tmpdir)
1898
1500
                tmp_repo = tmp_bzrdir.open_repository()
1899
1501
                tmp_repo.copy_content_into(destination, revision_id)
1900
1502
            finally:
1916
1518
        return self._real_repository.inventories
1917
1519
 
1918
1520
    @needs_write_lock
1919
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1521
    def pack(self, hint=None):
1920
1522
        """Compress the data within the repository.
1921
1523
 
1922
1524
        This is not currently implemented within the smart server.
1923
1525
        """
1924
1526
        self._ensure_real()
1925
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1527
        return self._real_repository.pack(hint=hint)
1926
1528
 
1927
1529
    @property
1928
1530
    def revisions(self):
1985
1587
    def supports_rich_root(self):
1986
1588
        return self._format.rich_root_data
1987
1589
 
1988
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1989
1590
    def iter_reverse_revision_history(self, revision_id):
1990
1591
        self._ensure_real()
1991
1592
        return self._real_repository.iter_reverse_revision_history(revision_id)
2012
1613
        return self._real_repository.item_keys_introduced_by(revision_ids,
2013
1614
            _files_pb=_files_pb)
2014
1615
 
2015
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
2016
 
        self._ensure_real()
2017
 
        return self._real_repository._find_inconsistent_revision_parents(
2018
 
            revisions_iterator)
 
1616
    def revision_graph_can_have_wrong_parents(self):
 
1617
        # The answer depends on the remote repo format.
 
1618
        self._ensure_real()
 
1619
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
1620
 
 
1621
    def _find_inconsistent_revision_parents(self):
 
1622
        self._ensure_real()
 
1623
        return self._real_repository._find_inconsistent_revision_parents()
2019
1624
 
2020
1625
    def _check_for_inconsistent_revision_parents(self):
2021
1626
        self._ensure_real()
2025
1630
        providers = [self._unstacked_provider]
2026
1631
        if other is not None:
2027
1632
            providers.insert(0, other)
2028
 
        return graph.StackedParentsProvider(_LazyListJoin(
2029
 
            providers, self._fallback_repositories))
 
1633
        providers.extend(r._make_parents_provider() for r in
 
1634
                         self._fallback_repositories)
 
1635
        return graph.StackedParentsProvider(providers)
2030
1636
 
2031
1637
    def _serialise_search_recipe(self, recipe):
2032
1638
        """Serialise a graph search recipe.
2040
1646
        return '\n'.join((start_keys, stop_keys, count))
2041
1647
 
2042
1648
    def _serialise_search_result(self, search_result):
2043
 
        parts = search_result.get_network_struct()
 
1649
        if isinstance(search_result, graph.PendingAncestryResult):
 
1650
            parts = ['ancestry-of']
 
1651
            parts.extend(search_result.heads)
 
1652
        else:
 
1653
            recipe = search_result.get_recipe()
 
1654
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
2044
1655
        return '\n'.join(parts)
2045
1656
 
2046
1657
    def autopack(self):
2056
1667
            raise errors.UnexpectedSmartServerResponse(response)
2057
1668
 
2058
1669
 
2059
 
class RemoteStreamSink(vf_repository.StreamSink):
 
1670
class RemoteStreamSink(repository.StreamSink):
2060
1671
 
2061
1672
    def _insert_real(self, stream, src_format, resume_tokens):
2062
1673
        self.target_repo._ensure_real()
2069
1680
    def insert_stream(self, stream, src_format, resume_tokens):
2070
1681
        target = self.target_repo
2071
1682
        target._unstacked_provider.missing_keys.clear()
2072
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
2073
1683
        if target._lock_token:
2074
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
2075
 
            lock_args = (target._lock_token or '',)
 
1684
            verb = 'Repository.insert_stream_locked'
 
1685
            extra_args = (target._lock_token or '',)
 
1686
            required_version = (1, 14)
2076
1687
        else:
2077
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
2078
 
            lock_args = ()
 
1688
            verb = 'Repository.insert_stream'
 
1689
            extra_args = ()
 
1690
            required_version = (1, 13)
2079
1691
        client = target._client
2080
1692
        medium = client._medium
 
1693
        if medium._is_remote_before(required_version):
 
1694
            # No possible way this can work.
 
1695
            return self._insert_real(stream, src_format, resume_tokens)
2081
1696
        path = target.bzrdir._path_for_remote_call(client)
2082
 
        # Probe for the verb to use with an empty stream before sending the
2083
 
        # real stream to it.  We do this both to avoid the risk of sending a
2084
 
        # large request that is then rejected, and because we don't want to
2085
 
        # implement a way to buffer, rewind, or restart the stream.
2086
 
        found_verb = False
2087
 
        for verb, required_version in candidate_calls:
2088
 
            if medium._is_remote_before(required_version):
2089
 
                continue
2090
 
            if resume_tokens:
2091
 
                # We've already done the probing (and set _is_remote_before) on
2092
 
                # a previous insert.
2093
 
                found_verb = True
2094
 
                break
 
1697
        if not resume_tokens:
 
1698
            # XXX: Ugly but important for correctness, *will* be fixed during
 
1699
            # 1.13 cycle. Pushing a stream that is interrupted results in a
 
1700
            # fallback to the _real_repositories sink *with a partial stream*.
 
1701
            # Thats bad because we insert less data than bzr expected. To avoid
 
1702
            # this we do a trial push to make sure the verb is accessible, and
 
1703
            # do not fallback when actually pushing the stream. A cleanup patch
 
1704
            # is going to look at rewinding/restarting the stream/partial
 
1705
            # buffering etc.
2095
1706
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
2096
1707
            try:
2097
1708
                response = client.call_with_body_stream(
2098
 
                    (verb, path, '') + lock_args, byte_stream)
 
1709
                    (verb, path, '') + extra_args, byte_stream)
2099
1710
            except errors.UnknownSmartMethod:
2100
1711
                medium._remember_remote_is_before(required_version)
2101
 
            else:
2102
 
                found_verb = True
2103
 
                break
2104
 
        if not found_verb:
2105
 
            # Have to use VFS.
2106
 
            return self._insert_real(stream, src_format, resume_tokens)
2107
 
        self._last_inv_record = None
2108
 
        self._last_substream = None
2109
 
        if required_version < (1, 19):
2110
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
2111
 
            # make sure we don't send any.  If the stream contains inventory
2112
 
            # deltas we'll interrupt the smart insert_stream request and
2113
 
            # fallback to VFS.
2114
 
            stream = self._stop_stream_if_inventory_delta(stream)
 
1712
                return self._insert_real(stream, src_format, resume_tokens)
2115
1713
        byte_stream = smart_repo._stream_to_byte_stream(
2116
1714
            stream, src_format)
2117
1715
        resume_tokens = ' '.join(resume_tokens)
2118
1716
        response = client.call_with_body_stream(
2119
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1717
            (verb, path, resume_tokens) + extra_args, byte_stream)
2120
1718
        if response[0][0] not in ('ok', 'missing-basis'):
2121
1719
            raise errors.UnexpectedSmartServerResponse(response)
2122
 
        if self._last_substream is not None:
2123
 
            # The stream included an inventory-delta record, but the remote
2124
 
            # side isn't new enough to support them.  So we need to send the
2125
 
            # rest of the stream via VFS.
2126
 
            self.target_repo.refresh_data()
2127
 
            return self._resume_stream_with_vfs(response, src_format)
2128
1720
        if response[0][0] == 'missing-basis':
2129
1721
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
2130
1722
            resume_tokens = tokens
2133
1725
            self.target_repo.refresh_data()
2134
1726
            return [], set()
2135
1727
 
2136
 
    def _resume_stream_with_vfs(self, response, src_format):
2137
 
        """Resume sending a stream via VFS, first resending the record and
2138
 
        substream that couldn't be sent via an insert_stream verb.
2139
 
        """
2140
 
        if response[0][0] == 'missing-basis':
2141
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
2142
 
            # Ignore missing_keys, we haven't finished inserting yet
2143
 
        else:
2144
 
            tokens = []
2145
 
        def resume_substream():
2146
 
            # Yield the substream that was interrupted.
2147
 
            for record in self._last_substream:
2148
 
                yield record
2149
 
            self._last_substream = None
2150
 
        def resume_stream():
2151
 
            # Finish sending the interrupted substream
2152
 
            yield ('inventory-deltas', resume_substream())
2153
 
            # Then simply continue sending the rest of the stream.
2154
 
            for substream_kind, substream in self._last_stream:
2155
 
                yield substream_kind, substream
2156
 
        return self._insert_real(resume_stream(), src_format, tokens)
2157
 
 
2158
 
    def _stop_stream_if_inventory_delta(self, stream):
2159
 
        """Normally this just lets the original stream pass-through unchanged.
2160
 
 
2161
 
        However if any 'inventory-deltas' substream occurs it will stop
2162
 
        streaming, and store the interrupted substream and stream in
2163
 
        self._last_substream and self._last_stream so that the stream can be
2164
 
        resumed by _resume_stream_with_vfs.
2165
 
        """
2166
 
 
2167
 
        stream_iter = iter(stream)
2168
 
        for substream_kind, substream in stream_iter:
2169
 
            if substream_kind == 'inventory-deltas':
2170
 
                self._last_substream = substream
2171
 
                self._last_stream = stream_iter
2172
 
                return
2173
 
            else:
2174
 
                yield substream_kind, substream
2175
 
 
2176
 
 
2177
 
class RemoteStreamSource(vf_repository.StreamSource):
 
1728
 
 
1729
class RemoteStreamSource(repository.StreamSource):
2178
1730
    """Stream data from a remote server."""
2179
1731
 
2180
1732
    def get_stream(self, search):
2181
1733
        if (self.from_repository._fallback_repositories and
2182
1734
            self.to_format._fetch_order == 'topological'):
2183
1735
            return self._real_stream(self.from_repository, search)
2184
 
        sources = []
2185
 
        seen = set()
2186
 
        repos = [self.from_repository]
2187
 
        while repos:
2188
 
            repo = repos.pop(0)
2189
 
            if repo in seen:
2190
 
                continue
2191
 
            seen.add(repo)
2192
 
            repos.extend(repo._fallback_repositories)
2193
 
            sources.append(repo)
2194
 
        return self.missing_parents_chain(search, sources)
2195
 
 
2196
 
    def get_stream_for_missing_keys(self, missing_keys):
2197
 
        self.from_repository._ensure_real()
2198
 
        real_repo = self.from_repository._real_repository
2199
 
        real_source = real_repo._get_source(self.to_format)
2200
 
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1736
        return self.missing_parents_chain(search, [self.from_repository] +
 
1737
            self.from_repository._fallback_repositories)
2201
1738
 
2202
1739
    def _real_stream(self, repo, search):
2203
1740
        """Get a stream for search from repo.
2210
1747
        """
2211
1748
        source = repo._get_source(self.to_format)
2212
1749
        if isinstance(source, RemoteStreamSource):
2213
 
            repo._ensure_real()
2214
 
            source = repo._real_repository._get_source(self.to_format)
 
1750
            return repository.StreamSource.get_stream(source, search)
2215
1751
        return source.get_stream(search)
2216
1752
 
2217
1753
    def _get_stream(self, repo, search):
2234
1770
            return self._real_stream(repo, search)
2235
1771
        client = repo._client
2236
1772
        medium = client._medium
 
1773
        if medium._is_remote_before((1, 13)):
 
1774
            # streaming was added in 1.13
 
1775
            return self._real_stream(repo, search)
2237
1776
        path = repo.bzrdir._path_for_remote_call(client)
2238
 
        search_bytes = repo._serialise_search_result(search)
2239
 
        args = (path, self.to_format.network_name())
2240
 
        candidate_verbs = [
2241
 
            ('Repository.get_stream_1.19', (1, 19)),
2242
 
            ('Repository.get_stream', (1, 13))]
2243
 
 
2244
 
        found_verb = False
2245
 
        for verb, version in candidate_verbs:
2246
 
            if medium._is_remote_before(version):
2247
 
                continue
2248
 
            try:
2249
 
                response = repo._call_with_body_bytes_expecting_body(
2250
 
                    verb, args, search_bytes)
2251
 
            except errors.UnknownSmartMethod:
2252
 
                medium._remember_remote_is_before(version)
2253
 
            except errors.UnknownErrorFromSmartServer, e:
2254
 
                if isinstance(search, graph.EverythingResult):
2255
 
                    error_verb = e.error_from_smart_server.error_verb
2256
 
                    if error_verb == 'BadSearch':
2257
 
                        # Pre-2.4 servers don't support this sort of search.
2258
 
                        # XXX: perhaps falling back to VFS on BadSearch is a
2259
 
                        # good idea in general?  It might provide a little bit
2260
 
                        # of protection against client-side bugs.
2261
 
                        medium._remember_remote_is_before((2, 4))
2262
 
                        break
2263
 
                raise
2264
 
            else:
2265
 
                response_tuple, response_handler = response
2266
 
                found_verb = True
2267
 
                break
2268
 
        if not found_verb:
 
1777
        try:
 
1778
            search_bytes = repo._serialise_search_result(search)
 
1779
            response = repo._call_with_body_bytes_expecting_body(
 
1780
                'Repository.get_stream',
 
1781
                (path, self.to_format.network_name()), search_bytes)
 
1782
            response_tuple, response_handler = response
 
1783
        except errors.UnknownSmartMethod:
 
1784
            medium._remember_remote_is_before((1,13))
2269
1785
            return self._real_stream(repo, search)
2270
1786
        if response_tuple[0] != 'ok':
2271
1787
            raise errors.UnexpectedSmartServerResponse(response_tuple)
2272
1788
        byte_stream = response_handler.read_streamed_body()
2273
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
2274
 
            self._record_counter)
 
1789
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
2275
1790
        if src_format.network_name() != repo._format.network_name():
2276
1791
            raise AssertionError(
2277
1792
                "Mismatched RemoteRepository and stream src %r, %r" % (
2284
1799
        :param search: The overall search to satisfy with streams.
2285
1800
        :param sources: A list of Repository objects to query.
2286
1801
        """
2287
 
        self.from_serialiser = self.from_repository._format._serializer
 
1802
        self.serialiser = self.to_format._serializer
2288
1803
        self.seen_revs = set()
2289
1804
        self.referenced_revs = set()
2290
1805
        # If there are heads in the search, or the key count is > 0, we are not
2307
1822
    def missing_parents_rev_handler(self, substream):
2308
1823
        for content in substream:
2309
1824
            revision_bytes = content.get_bytes_as('fulltext')
2310
 
            revision = self.from_serialiser.read_revision_from_string(
2311
 
                revision_bytes)
 
1825
            revision = self.serialiser.read_revision_from_string(revision_bytes)
2312
1826
            self.seen_revs.add(content.key[-1])
2313
1827
            self.referenced_revs.update(revision.parent_ids)
2314
1828
            yield content
2353
1867
                self._network_name)
2354
1868
 
2355
1869
    def get_format_description(self):
2356
 
        self._ensure_real()
2357
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1870
        return 'Remote BZR Branch'
2358
1871
 
2359
1872
    def network_name(self):
2360
1873
        return self._network_name
2361
1874
 
2362
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2363
 
        return a_bzrdir.open_branch(name=name, 
2364
 
            ignore_fallbacks=ignore_fallbacks)
 
1875
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
1876
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2365
1877
 
2366
 
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
 
1878
    def _vfs_initialize(self, a_bzrdir):
2367
1879
        # Initialisation when using a local bzrdir object, or a non-vfs init
2368
1880
        # method is not available on the server.
2369
1881
        # self._custom_format is always set - the start of initialize ensures
2370
1882
        # that.
2371
1883
        if isinstance(a_bzrdir, RemoteBzrDir):
2372
1884
            a_bzrdir._ensure_real()
2373
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2374
 
                name, append_revisions_only=append_revisions_only)
 
1885
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2375
1886
        else:
2376
1887
            # We assume the bzrdir is parameterised; it may not be.
2377
 
            result = self._custom_format.initialize(a_bzrdir, name,
2378
 
                append_revisions_only=append_revisions_only)
 
1888
            result = self._custom_format.initialize(a_bzrdir)
2379
1889
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2380
1890
            not isinstance(result, RemoteBranch)):
2381
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2382
 
                                  name=name)
 
1891
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2383
1892
        return result
2384
1893
 
2385
 
    def initialize(self, a_bzrdir, name=None, repository=None,
2386
 
                   append_revisions_only=None):
 
1894
    def initialize(self, a_bzrdir):
2387
1895
        # 1) get the network name to use.
2388
1896
        if self._custom_format:
2389
1897
            network_name = self._custom_format.network_name()
2390
1898
        else:
2391
1899
            # Select the current bzrlib default and ask for that.
2392
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
1900
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
2393
1901
            reference_format = reference_bzrdir_format.get_branch_format()
2394
1902
            self._custom_format = reference_format
2395
1903
            network_name = reference_format.network_name()
2396
1904
        # Being asked to create on a non RemoteBzrDir:
2397
1905
        if not isinstance(a_bzrdir, RemoteBzrDir):
2398
 
            return self._vfs_initialize(a_bzrdir, name=name,
2399
 
                append_revisions_only=append_revisions_only)
 
1906
            return self._vfs_initialize(a_bzrdir)
2400
1907
        medium = a_bzrdir._client._medium
2401
1908
        if medium._is_remote_before((1, 13)):
2402
 
            return self._vfs_initialize(a_bzrdir, name=name,
2403
 
                append_revisions_only=append_revisions_only)
 
1909
            return self._vfs_initialize(a_bzrdir)
2404
1910
        # Creating on a remote bzr dir.
2405
1911
        # 2) try direct creation via RPC
2406
1912
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2407
 
        if name is not None:
2408
 
            # XXX JRV20100304: Support creating colocated branches
2409
 
            raise errors.NoColocatedBranchSupport(self)
2410
1913
        verb = 'BzrDir.create_branch'
2411
1914
        try:
2412
1915
            response = a_bzrdir._call(verb, path, network_name)
2413
1916
        except errors.UnknownSmartMethod:
2414
1917
            # Fallback - use vfs methods
2415
1918
            medium._remember_remote_is_before((1, 13))
2416
 
            return self._vfs_initialize(a_bzrdir, name=name,
2417
 
                    append_revisions_only=append_revisions_only)
 
1919
            return self._vfs_initialize(a_bzrdir)
2418
1920
        if response[0] != 'ok':
2419
1921
            raise errors.UnexpectedSmartServerResponse(response)
2420
1922
        # Turn the response into a RemoteRepository object.
2421
1923
        format = RemoteBranchFormat(network_name=response[1])
2422
1924
        repo_format = response_tuple_to_repo_format(response[3:])
2423
 
        repo_path = response[2]
2424
 
        if repository is not None:
2425
 
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
2426
 
            url_diff = urlutils.relative_url(repository.user_url,
2427
 
                    remote_repo_url)
2428
 
            if url_diff != '.':
2429
 
                raise AssertionError(
2430
 
                    'repository.user_url %r does not match URL from server '
2431
 
                    'response (%r + %r)'
2432
 
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
2433
 
            remote_repo = repository
 
1925
        if response[2] == '':
 
1926
            repo_bzrdir = a_bzrdir
2434
1927
        else:
2435
 
            if repo_path == '':
2436
 
                repo_bzrdir = a_bzrdir
2437
 
            else:
2438
 
                repo_bzrdir = RemoteBzrDir(
2439
 
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
2440
 
                    a_bzrdir._client)
2441
 
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
1928
            repo_bzrdir = RemoteBzrDir(
 
1929
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
 
1930
                a_bzrdir._client)
 
1931
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2442
1932
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2443
 
            format=format, setup_stacking=False, name=name)
2444
 
        if append_revisions_only:
2445
 
            remote_branch.set_append_revisions_only(append_revisions_only)
 
1933
            format=format, setup_stacking=False)
2446
1934
        # XXX: We know this is a new branch, so it must have revno 0, revid
2447
1935
        # NULL_REVISION. Creating the branch locked would make this be unable
2448
1936
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2467
1955
        self._ensure_real()
2468
1956
        return self._custom_format.supports_set_append_revisions_only()
2469
1957
 
2470
 
    def _use_default_local_heads_to_fetch(self):
2471
 
        # If the branch format is a metadir format *and* its heads_to_fetch
2472
 
        # implementation is not overridden vs the base class, we can use the
2473
 
        # base class logic rather than use the heads_to_fetch RPC.  This is
2474
 
        # usually cheaper in terms of net round trips, as the last-revision and
2475
 
        # tags info fetched is cached and would be fetched anyway.
2476
 
        self._ensure_real()
2477
 
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
2478
 
            branch_class = self._custom_format._branch_class()
2479
 
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
2480
 
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
2481
 
                return True
2482
 
        return False
2483
1958
 
2484
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1959
class RemoteBranch(branch.Branch, _RpcHelper):
2485
1960
    """Branch stored on a server accessed by HPSS RPC.
2486
1961
 
2487
1962
    At the moment most operations are mapped down to simple file operations.
2488
1963
    """
2489
1964
 
2490
1965
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2491
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1966
        _client=None, format=None, setup_stacking=True):
2492
1967
        """Create a RemoteBranch instance.
2493
1968
 
2494
1969
        :param real_branch: An optional local implementation of the branch
2500
1975
        :param setup_stacking: If True make an RPC call to determine the
2501
1976
            stacked (or not) status of the branch. If False assume the branch
2502
1977
            is not stacked.
2503
 
        :param name: Colocated branch name
2504
1978
        """
2505
1979
        # We intentionally don't call the parent class's __init__, because it
2506
1980
        # will try to assign to self.tags, which is a property in this subclass.
2525
1999
            self._real_branch = None
2526
2000
        # Fill out expected attributes of branch for bzrlib API users.
2527
2001
        self._clear_cached_state()
2528
 
        # TODO: deprecate self.base in favor of user_url
2529
 
        self.base = self.bzrdir.user_url
2530
 
        self._name = name
 
2002
        self.base = self.bzrdir.root_transport.base
2531
2003
        self._control_files = None
2532
2004
        self._lock_mode = None
2533
2005
        self._lock_token = None
2544
2016
                    self._real_branch._format.network_name()
2545
2017
        else:
2546
2018
            self._format = format
2547
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2548
 
        # branch.open_branch method.
2549
 
        self._real_ignore_fallbacks = not setup_stacking
2550
2019
        if not self._format._network_name:
2551
2020
            # Did not get from open_branchV2 - old server.
2552
2021
            self._ensure_real()
2597
2066
                raise AssertionError('smart server vfs must be enabled '
2598
2067
                    'to use vfs implementation')
2599
2068
            self.bzrdir._ensure_real()
2600
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2601
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
2069
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2602
2070
            if self.repository._real_repository is None:
2603
2071
                # Give the remote repository the matching real repo.
2604
2072
                real_repo = self._real_branch.repository
2643
2111
                self.bzrdir, self._client)
2644
2112
        return self._control_files
2645
2113
 
2646
 
    def _get_checkout_format(self, lightweight=False):
 
2114
    def _get_checkout_format(self):
2647
2115
        self._ensure_real()
2648
 
        if lightweight:
2649
 
            format = RemoteBzrDirFormat()
2650
 
            self.bzrdir._format._supply_sub_formats_to(format)
2651
 
            format.workingtree_format = self._real_branch._get_checkout_format(
2652
 
                lightweight=lightweight).workingtree_format
2653
 
            return format
2654
 
        else:
2655
 
            return self._real_branch._get_checkout_format(lightweight=False)
 
2116
        return self._real_branch._get_checkout_format()
2656
2117
 
2657
2118
    def get_physical_lock_status(self):
2658
2119
        """See Branch.get_physical_lock_status()."""
2691
2152
            self._is_stacked = False
2692
2153
        else:
2693
2154
            self._is_stacked = True
2694
 
 
 
2155
        
2695
2156
    def _vfs_get_tags_bytes(self):
2696
2157
        self._ensure_real()
2697
2158
        return self._real_branch._get_tags_bytes()
2698
2159
 
2699
 
    @needs_read_lock
2700
2160
    def _get_tags_bytes(self):
2701
 
        if self._tags_bytes is None:
2702
 
            self._tags_bytes = self._get_tags_bytes_via_hpss()
2703
 
        return self._tags_bytes
2704
 
 
2705
 
    def _get_tags_bytes_via_hpss(self):
2706
2161
        medium = self._client._medium
2707
2162
        if medium._is_remote_before((1, 13)):
2708
2163
            return self._vfs_get_tags_bytes()
2718
2173
        return self._real_branch._set_tags_bytes(bytes)
2719
2174
 
2720
2175
    def _set_tags_bytes(self, bytes):
2721
 
        if self.is_locked():
2722
 
            self._tags_bytes = bytes
2723
2176
        medium = self._client._medium
2724
2177
        if medium._is_remote_before((1, 18)):
2725
2178
            self._vfs_set_tags_bytes(bytes)
2726
 
            return
2727
2179
        try:
2728
2180
            args = (
2729
2181
                self._remote_path(), self._lock_token, self._repo_lock_token)
2734
2186
            self._vfs_set_tags_bytes(bytes)
2735
2187
 
2736
2188
    def lock_read(self):
2737
 
        """Lock the branch for read operations.
2738
 
 
2739
 
        :return: A bzrlib.lock.LogicalLockResult.
2740
 
        """
2741
2189
        self.repository.lock_read()
2742
2190
        if not self._lock_mode:
2743
 
            self._note_lock('r')
2744
2191
            self._lock_mode = 'r'
2745
2192
            self._lock_count = 1
2746
2193
            if self._real_branch is not None:
2747
2194
                self._real_branch.lock_read()
2748
2195
        else:
2749
2196
            self._lock_count += 1
2750
 
        return lock.LogicalLockResult(self.unlock)
2751
2197
 
2752
2198
    def _remote_lock_write(self, token):
2753
2199
        if token is None:
2754
2200
            branch_token = repo_token = ''
2755
2201
        else:
2756
2202
            branch_token = token
2757
 
            repo_token = self.repository.lock_write().repository_token
 
2203
            repo_token = self.repository.lock_write()
2758
2204
            self.repository.unlock()
2759
2205
        err_context = {'token': token}
2760
 
        try:
2761
 
            response = self._call(
2762
 
                'Branch.lock_write', self._remote_path(), branch_token,
2763
 
                repo_token or '', **err_context)
2764
 
        except errors.LockContention, e:
2765
 
            # The LockContention from the server doesn't have any
2766
 
            # information about the lock_url. We re-raise LockContention
2767
 
            # with valid lock_url.
2768
 
            raise errors.LockContention('(remote lock)',
2769
 
                self.repository.base.split('.bzr/')[0])
 
2206
        response = self._call(
 
2207
            'Branch.lock_write', self._remote_path(), branch_token,
 
2208
            repo_token or '', **err_context)
2770
2209
        if response[0] != 'ok':
2771
2210
            raise errors.UnexpectedSmartServerResponse(response)
2772
2211
        ok, branch_token, repo_token = response
2774
2213
 
2775
2214
    def lock_write(self, token=None):
2776
2215
        if not self._lock_mode:
2777
 
            self._note_lock('w')
2778
2216
            # Lock the branch and repo in one remote call.
2779
2217
            remote_tokens = self._remote_lock_write(token)
2780
2218
            self._lock_token, self._repo_lock_token = remote_tokens
2793
2231
            self._lock_mode = 'w'
2794
2232
            self._lock_count = 1
2795
2233
        elif self._lock_mode == 'r':
2796
 
            raise errors.ReadOnlyError(self)
 
2234
            raise errors.ReadOnlyTransaction
2797
2235
        else:
2798
2236
            if token is not None:
2799
2237
                # A token was given to lock_write, and we're relocking, so
2804
2242
            self._lock_count += 1
2805
2243
            # Re-lock the repository too.
2806
2244
            self.repository.lock_write(self._repo_lock_token)
2807
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2245
        return self._lock_token or None
2808
2246
 
2809
2247
    def _unlock(self, branch_token, repo_token):
2810
2248
        err_context = {'token': str((branch_token, repo_token))}
2815
2253
            return
2816
2254
        raise errors.UnexpectedSmartServerResponse(response)
2817
2255
 
2818
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2819
2256
    def unlock(self):
2820
2257
        try:
2821
2258
            self._lock_count -= 1
2861
2298
            raise NotImplementedError(self.dont_leave_lock_in_place)
2862
2299
        self._leave_lock = False
2863
2300
 
2864
 
    @needs_read_lock
2865
2301
    def get_rev_id(self, revno, history=None):
2866
2302
        if revno == 0:
2867
2303
            return _mod_revision.NULL_REVISION
2879
2315
            missing_parent = parent_map[missing_parent]
2880
2316
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2881
2317
 
2882
 
    def _read_last_revision_info(self):
 
2318
    def _last_revision_info(self):
2883
2319
        response = self._call('Branch.last_revision_info', self._remote_path())
2884
2320
        if response[0] != 'ok':
2885
2321
            raise SmartProtocolError('unexpected response code %s' % (response,))
2948
2384
            raise errors.UnexpectedSmartServerResponse(response)
2949
2385
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2950
2386
 
2951
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2952
2387
    @needs_write_lock
2953
2388
    def set_revision_history(self, rev_history):
2954
 
        """See Branch.set_revision_history."""
2955
 
        self._set_revision_history(rev_history)
2956
 
 
2957
 
    @needs_write_lock
2958
 
    def _set_revision_history(self, rev_history):
2959
2389
        # Send just the tip revision of the history; the server will generate
2960
2390
        # the full history from that.  If the revision doesn't exist in this
2961
2391
        # branch, NoSuchRevision will be raised.
3019
2449
            _override_hook_target=self, **kwargs)
3020
2450
 
3021
2451
    @needs_read_lock
3022
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
 
2452
    def push(self, target, overwrite=False, stop_revision=None):
3023
2453
        self._ensure_real()
3024
2454
        return self._real_branch.push(
3025
 
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
 
2455
            target, overwrite=overwrite, stop_revision=stop_revision,
3026
2456
            _override_hook_source_branch=self)
3027
2457
 
3028
2458
    def is_locked(self):
3038
2468
        # XXX: These should be returned by the set_last_revision_info verb
3039
2469
        old_revno, old_revid = self.last_revision_info()
3040
2470
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
3041
 
        if not revision_id or not isinstance(revision_id, basestring):
3042
 
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2471
        revision_id = ensure_null(revision_id)
3043
2472
        try:
3044
2473
            response = self._call('Branch.set_last_revision_info',
3045
2474
                self._remote_path(), self._lock_token, self._repo_lock_token,
3074
2503
            except errors.UnknownSmartMethod:
3075
2504
                medium._remember_remote_is_before((1, 6))
3076
2505
        self._clear_cached_state_of_remote_branch_only()
3077
 
        self._set_revision_history(self._lefthand_history(revision_id,
 
2506
        self.set_revision_history(self._lefthand_history(revision_id,
3078
2507
            last_rev=last_rev,other_branch=other_branch))
3079
2508
 
3080
2509
    def set_push_location(self, location):
3081
2510
        self._ensure_real()
3082
2511
        return self._real_branch.set_push_location(location)
3083
2512
 
3084
 
    def heads_to_fetch(self):
3085
 
        if self._format._use_default_local_heads_to_fetch():
3086
 
            # We recognise this format, and its heads-to-fetch implementation
3087
 
            # is the default one (tip + tags).  In this case it's cheaper to
3088
 
            # just use the default implementation rather than a special RPC as
3089
 
            # the tip and tags data is cached.
3090
 
            return branch.Branch.heads_to_fetch(self)
3091
 
        medium = self._client._medium
3092
 
        if medium._is_remote_before((2, 4)):
3093
 
            return self._vfs_heads_to_fetch()
3094
 
        try:
3095
 
            return self._rpc_heads_to_fetch()
3096
 
        except errors.UnknownSmartMethod:
3097
 
            medium._remember_remote_is_before((2, 4))
3098
 
            return self._vfs_heads_to_fetch()
3099
 
 
3100
 
    def _rpc_heads_to_fetch(self):
3101
 
        response = self._call('Branch.heads_to_fetch', self._remote_path())
3102
 
        if len(response) != 2:
3103
 
            raise errors.UnexpectedSmartServerResponse(response)
3104
 
        must_fetch, if_present_fetch = response
3105
 
        return set(must_fetch), set(if_present_fetch)
3106
 
 
3107
 
    def _vfs_heads_to_fetch(self):
3108
 
        self._ensure_real()
3109
 
        return self._real_branch.heads_to_fetch()
3110
 
 
3111
2513
 
3112
2514
class RemoteConfig(object):
3113
2515
    """A Config that reads and writes from smart verbs.
3127
2529
        """
3128
2530
        try:
3129
2531
            configobj = self._get_configobj()
3130
 
            section_obj = None
3131
2532
            if section is None:
3132
2533
                section_obj = configobj
3133
2534
            else:
3134
2535
                try:
3135
2536
                    section_obj = configobj[section]
3136
2537
                except KeyError:
3137
 
                    pass
3138
 
            if section_obj is None:
3139
 
                value = default
3140
 
            else:
3141
 
                value = section_obj.get(name, default)
 
2538
                    return default
 
2539
            return section_obj.get(name, default)
3142
2540
        except errors.UnknownSmartMethod:
3143
 
            value = self._vfs_get_option(name, section, default)
3144
 
        for hook in config.OldConfigHooks['get']:
3145
 
            hook(self, name, value)
3146
 
        return value
 
2541
            return self._vfs_get_option(name, section, default)
3147
2542
 
3148
2543
    def _response_to_configobj(self, response):
3149
2544
        if len(response[0]) and response[0][0] != 'ok':
3150
2545
            raise errors.UnexpectedSmartServerResponse(response)
3151
2546
        lines = response[1].read_body_bytes().splitlines()
3152
 
        conf = config.ConfigObj(lines, encoding='utf-8')
3153
 
        for hook in config.OldConfigHooks['load']:
3154
 
            hook(self)
3155
 
        return conf
 
2547
        return config.ConfigObj(lines, encoding='utf-8')
3156
2548
 
3157
2549
 
3158
2550
class RemoteBranchConfig(RemoteConfig):
3177
2569
        medium = self._branch._client._medium
3178
2570
        if medium._is_remote_before((1, 14)):
3179
2571
            return self._vfs_set_option(value, name, section)
3180
 
        if isinstance(value, dict):
3181
 
            if medium._is_remote_before((2, 2)):
3182
 
                return self._vfs_set_option(value, name, section)
3183
 
            return self._set_config_option_dict(value, name, section)
3184
 
        else:
3185
 
            return self._set_config_option(value, name, section)
3186
 
 
3187
 
    def _set_config_option(self, value, name, section):
3188
2572
        try:
3189
2573
            path = self._branch._remote_path()
3190
2574
            response = self._branch._client.call('Branch.set_config_option',
3191
2575
                path, self._branch._lock_token, self._branch._repo_lock_token,
3192
2576
                value.encode('utf8'), name, section or '')
3193
2577
        except errors.UnknownSmartMethod:
3194
 
            medium = self._branch._client._medium
3195
2578
            medium._remember_remote_is_before((1, 14))
3196
2579
            return self._vfs_set_option(value, name, section)
3197
2580
        if response != ():
3198
2581
            raise errors.UnexpectedSmartServerResponse(response)
3199
2582
 
3200
 
    def _serialize_option_dict(self, option_dict):
3201
 
        utf8_dict = {}
3202
 
        for key, value in option_dict.items():
3203
 
            if isinstance(key, unicode):
3204
 
                key = key.encode('utf8')
3205
 
            if isinstance(value, unicode):
3206
 
                value = value.encode('utf8')
3207
 
            utf8_dict[key] = value
3208
 
        return bencode.bencode(utf8_dict)
3209
 
 
3210
 
    def _set_config_option_dict(self, value, name, section):
3211
 
        try:
3212
 
            path = self._branch._remote_path()
3213
 
            serialised_dict = self._serialize_option_dict(value)
3214
 
            response = self._branch._client.call(
3215
 
                'Branch.set_config_option_dict',
3216
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
3217
 
                serialised_dict, name, section or '')
3218
 
        except errors.UnknownSmartMethod:
3219
 
            medium = self._branch._client._medium
3220
 
            medium._remember_remote_is_before((2, 2))
3221
 
            return self._vfs_set_option(value, name, section)
3222
 
        if response != ():
3223
 
            raise errors.UnexpectedSmartServerResponse(response)
3224
 
 
3225
2583
    def _real_object(self):
3226
2584
        self._branch._ensure_real()
3227
2585
        return self._branch._real_branch
3314
2672
        raise NoSuchRevision(find('branch'), err.error_args[0])
3315
2673
    elif err.error_verb == 'nosuchrevision':
3316
2674
        raise NoSuchRevision(find('repository'), err.error_args[0])
3317
 
    elif err.error_verb == 'nobranch':
3318
 
        if len(err.error_args) >= 1:
3319
 
            extra = err.error_args[0]
3320
 
        else:
3321
 
            extra = None
3322
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3323
 
            detail=extra)
 
2675
    elif err.error_tuple == ('nobranch',):
 
2676
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
3324
2677
    elif err.error_verb == 'norepository':
3325
2678
        raise errors.NoRepositoryPresent(find('bzrdir'))
 
2679
    elif err.error_verb == 'LockContention':
 
2680
        raise errors.LockContention('(remote lock)')
3326
2681
    elif err.error_verb == 'UnlockableTransport':
3327
2682
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
 
2683
    elif err.error_verb == 'LockFailed':
 
2684
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3328
2685
    elif err.error_verb == 'TokenMismatch':
3329
2686
        raise errors.TokenMismatch(find('token'), '(remote token)')
3330
2687
    elif err.error_verb == 'Diverged':
3331
2688
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
 
2689
    elif err.error_verb == 'TipChangeRejected':
 
2690
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
2691
    elif err.error_verb == 'UnstackableBranchFormat':
 
2692
        raise errors.UnstackableBranchFormat(*err.error_args)
 
2693
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
2694
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3332
2695
    elif err.error_verb == 'NotStacked':
3333
2696
        raise errors.NotStacked(branch=find('branch'))
3334
2697
    elif err.error_verb == 'PermissionDenied':
3344
2707
    elif err.error_verb == 'NoSuchFile':
3345
2708
        path = get_path()
3346
2709
        raise errors.NoSuchFile(path)
3347
 
    _translate_error_without_context(err)
3348
 
 
3349
 
 
3350
 
def _translate_error_without_context(err):
3351
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3352
 
    if err.error_verb == 'IncompatibleRepositories':
3353
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3354
 
            err.error_args[1], err.error_args[2])
3355
 
    elif err.error_verb == 'LockContention':
3356
 
        raise errors.LockContention('(remote lock)')
3357
 
    elif err.error_verb == 'LockFailed':
3358
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3359
 
    elif err.error_verb == 'TipChangeRejected':
3360
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3361
 
    elif err.error_verb == 'UnstackableBranchFormat':
3362
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3363
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3364
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3365
2710
    elif err.error_verb == 'FileExists':
3366
2711
        raise errors.FileExists(err.error_args[0])
3367
2712
    elif err.error_verb == 'DirectoryNotEmpty':
3386
2731
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3387
2732
    elif err.error_verb == 'ReadOnlyError':
3388
2733
        raise errors.TransportNotPossible('readonly transport')
3389
 
    elif err.error_verb == 'MemoryError':
3390
 
        raise errors.BzrError("remote server out of memory\n"
3391
 
            "Retry non-remotely, or contact the server admin for details.")
3392
2734
    raise errors.UnknownErrorFromSmartServer(err)