← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: John Arbash Meinel
  • Date: 2009-10-12 21:44:27 UTC
  • mto: This revision was merged to the branch mainline in revision 4737.
  • Revision ID: john@arbash-meinel.com-20091012214427-zddi1kmc2jlf7v31
Py_ssize_t and its associated function typedefs are not available w/ python 2.4

So we define them in python-compat.h
Even further, gcc issued a warning for:
static int
_workaround_pyrex_096()
So we changed it to:
_workaround_pyrex_096(void)

Also, some python api funcs were incorrectly defined as 'char *' when they meant
'const char *'. Work around that with a (char *) cast, to avoid compiler warnings.

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
 
33
)
 
34
from bzrlib.branch import BranchReferenceFormat
 
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
36
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
37
from bzrlib.errors import (
40
38
    NoSuchRevision,
42
40
    )
43
41
from bzrlib.lockable_files import LockableFiles
44
42
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.smart.client import _SmartClient
46
 
from bzrlib.revision import NULL_REVISION
47
 
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
43
from bzrlib.revision import ensure_null, NULL_REVISION
48
44
from bzrlib.trace import mutter, note, warning
49
45
 
50
46
 
88
84
    return format
89
85
 
90
86
 
91
 
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
92
 
# does not have to be imported unless a remote format is involved.
93
 
 
94
 
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
95
 
    """Format representing bzrdirs accessed via a smart server"""
96
 
 
97
 
    supports_workingtrees = False
98
 
 
99
 
    def __init__(self):
100
 
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
101
 
        # XXX: It's a bit ugly that the network name is here, because we'd
102
 
        # like to believe that format objects are stateless or at least
103
 
        # immutable,  However, we do at least avoid mutating the name after
104
 
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
105
 
        self._network_name = None
106
 
 
107
 
    def __repr__(self):
108
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
109
 
            self._network_name)
110
 
 
111
 
    def get_format_description(self):
112
 
        if self._network_name:
113
 
            real_format = controldir.network_format_registry.get(self._network_name)
114
 
            return 'Remote: ' + real_format.get_format_description()
115
 
        return 'bzr remote bzrdir'
116
 
 
117
 
    def get_format_string(self):
118
 
        raise NotImplementedError(self.get_format_string)
119
 
 
120
 
    def network_name(self):
121
 
        if self._network_name:
122
 
            return self._network_name
123
 
        else:
124
 
            raise AssertionError("No network name set.")
125
 
 
126
 
    def initialize_on_transport(self, transport):
127
 
        try:
128
 
            # hand off the request to the smart server
129
 
            client_medium = transport.get_smart_medium()
130
 
        except errors.NoSmartMedium:
131
 
            # TODO: lookup the local format from a server hint.
132
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
133
 
            return local_dir_format.initialize_on_transport(transport)
134
 
        client = _SmartClient(client_medium)
135
 
        path = client.remote_path_from_transport(transport)
136
 
        try:
137
 
            response = client.call('BzrDirFormat.initialize', path)
138
 
        except errors.ErrorFromSmartServer, err:
139
 
            _translate_error(err, path=path)
140
 
        if response[0] != 'ok':
141
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
142
 
        format = RemoteBzrDirFormat()
143
 
        self._supply_sub_formats_to(format)
144
 
        return RemoteBzrDir(transport, format)
145
 
 
146
 
    def parse_NoneTrueFalse(self, arg):
147
 
        if not arg:
148
 
            return None
149
 
        if arg == 'False':
150
 
            return False
151
 
        if arg == 'True':
152
 
            return True
153
 
        raise AssertionError("invalid arg %r" % arg)
154
 
 
155
 
    def _serialize_NoneTrueFalse(self, arg):
156
 
        if arg is False:
157
 
            return 'False'
158
 
        if arg:
159
 
            return 'True'
160
 
        return ''
161
 
 
162
 
    def _serialize_NoneString(self, arg):
163
 
        return arg or ''
164
 
 
165
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
166
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
167
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
168
 
        shared_repo=False):
169
 
        try:
170
 
            # hand off the request to the smart server
171
 
            client_medium = transport.get_smart_medium()
172
 
        except errors.NoSmartMedium:
173
 
            do_vfs = True
174
 
        else:
175
 
            # Decline to open it if the server doesn't support our required
176
 
            # version (3) so that the VFS-based transport will do it.
177
 
            if client_medium.should_probe():
178
 
                try:
179
 
                    server_version = client_medium.protocol_version()
180
 
                    if server_version != '2':
181
 
                        do_vfs = True
182
 
                    else:
183
 
                        do_vfs = False
184
 
                except errors.SmartProtocolError:
185
 
                    # Apparently there's no usable smart server there, even though
186
 
                    # the medium supports the smart protocol.
187
 
                    do_vfs = True
188
 
            else:
189
 
                do_vfs = False
190
 
        if not do_vfs:
191
 
            client = _SmartClient(client_medium)
192
 
            path = client.remote_path_from_transport(transport)
193
 
            if client_medium._is_remote_before((1, 16)):
194
 
                do_vfs = True
195
 
        if do_vfs:
196
 
            # TODO: lookup the local format from a server hint.
197
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
198
 
            self._supply_sub_formats_to(local_dir_format)
199
 
            return local_dir_format.initialize_on_transport_ex(transport,
200
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
201
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
202
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
203
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
204
 
                vfs_only=True)
205
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
206
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
207
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
208
 
 
209
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
210
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
211
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
212
 
        args = []
213
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
214
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
215
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
216
 
        args.append(self._serialize_NoneString(stacked_on))
217
 
        # stack_on_pwd is often/usually our transport
218
 
        if stack_on_pwd:
219
 
            try:
220
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
221
 
                if not stack_on_pwd:
222
 
                    stack_on_pwd = '.'
223
 
            except errors.PathNotChild:
224
 
                pass
225
 
        args.append(self._serialize_NoneString(stack_on_pwd))
226
 
        args.append(self._serialize_NoneString(repo_format_name))
227
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
228
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
229
 
        request_network_name = self._network_name or \
230
 
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
231
 
        try:
232
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
233
 
                request_network_name, path, *args)
234
 
        except errors.UnknownSmartMethod:
235
 
            client._medium._remember_remote_is_before((1,16))
236
 
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
237
 
            self._supply_sub_formats_to(local_dir_format)
238
 
            return local_dir_format.initialize_on_transport_ex(transport,
239
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
240
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
241
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
242
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
243
 
                vfs_only=True)
244
 
        except errors.ErrorFromSmartServer, err:
245
 
            _translate_error(err, path=path)
246
 
        repo_path = response[0]
247
 
        bzrdir_name = response[6]
248
 
        require_stacking = response[7]
249
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
250
 
        format = RemoteBzrDirFormat()
251
 
        format._network_name = bzrdir_name
252
 
        self._supply_sub_formats_to(format)
253
 
        bzrdir = RemoteBzrDir(transport, format, _client=client)
254
 
        if repo_path:
255
 
            repo_format = response_tuple_to_repo_format(response[1:])
256
 
            if repo_path == '.':
257
 
                repo_path = ''
258
 
            if repo_path:
259
 
                repo_bzrdir_format = RemoteBzrDirFormat()
260
 
                repo_bzrdir_format._network_name = response[5]
261
 
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
262
 
                    repo_bzrdir_format)
263
 
            else:
264
 
                repo_bzr = bzrdir
265
 
            final_stack = response[8] or None
266
 
            final_stack_pwd = response[9] or None
267
 
            if final_stack_pwd:
268
 
                final_stack_pwd = urlutils.join(
269
 
                    transport.base, final_stack_pwd)
270
 
            remote_repo = RemoteRepository(repo_bzr, repo_format)
271
 
            if len(response) > 10:
272
 
                # Updated server verb that locks remotely.
273
 
                repo_lock_token = response[10] or None
274
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
275
 
                if repo_lock_token:
276
 
                    remote_repo.dont_leave_lock_in_place()
277
 
            else:
278
 
                remote_repo.lock_write()
279
 
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
280
 
                final_stack_pwd, require_stacking)
281
 
            policy.acquire_repository()
282
 
        else:
283
 
            remote_repo = None
284
 
            policy = None
285
 
        bzrdir._format.set_branch_format(self.get_branch_format())
286
 
        if require_stacking:
287
 
            # The repo has already been created, but we need to make sure that
288
 
            # we'll make a stackable branch.
289
 
            bzrdir._format.require_stacking(_skip_repo=True)
290
 
        return remote_repo, bzrdir, require_stacking, policy
291
 
 
292
 
    def _open(self, transport):
293
 
        return RemoteBzrDir(transport, self)
294
 
 
295
 
    def __eq__(self, other):
296
 
        if not isinstance(other, RemoteBzrDirFormat):
297
 
            return False
298
 
        return self.get_format_description() == other.get_format_description()
299
 
 
300
 
    def __return_repository_format(self):
301
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
302
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
303
 
        # that it should use that for init() etc.
304
 
        result = RemoteRepositoryFormat()
305
 
        custom_format = getattr(self, '_repository_format', None)
306
 
        if custom_format:
307
 
            if isinstance(custom_format, RemoteRepositoryFormat):
308
 
                return custom_format
309
 
            else:
310
 
                # We will use the custom format to create repositories over the
311
 
                # wire; expose its details like rich_root_data for code to
312
 
                # query
313
 
                result._custom_format = custom_format
314
 
        return result
315
 
 
316
 
    def get_branch_format(self):
317
 
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
318
 
        if not isinstance(result, RemoteBranchFormat):
319
 
            new_result = RemoteBranchFormat()
320
 
            new_result._custom_format = result
321
 
            # cache the result
322
 
            self.set_branch_format(new_result)
323
 
            result = new_result
324
 
        return result
325
 
 
326
 
    repository_format = property(__return_repository_format,
327
 
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
328
 
 
329
 
 
330
 
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
 
87
# Note: RemoteBzrDirFormat is in bzrdir.py
 
88
 
 
89
class RemoteBzrDir(BzrDir, _RpcHelper):
331
90
    """Control directory on a remote server, accessed via bzr:// or similar."""
332
91
 
333
92
    def __init__(self, transport, format, _client=None, _force_probe=False):
336
95
        :param _client: Private parameter for testing. Disables probing and the
337
96
            use of a real bzrdir.
338
97
        """
339
 
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
 
98
        BzrDir.__init__(self, transport, format)
340
99
        # this object holds a delegated bzrdir that uses file-level operations
341
100
        # to talk to the other side
342
101
        self._real_bzrdir = None
355
114
 
356
115
        self._probe_bzrdir()
357
116
 
358
 
    def __repr__(self):
359
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
360
 
 
361
117
    def _probe_bzrdir(self):
362
118
        medium = self._client._medium
363
119
        path = self._path_for_remote_call(self._client)
398
154
        Used before calls to self._real_bzrdir.
399
155
        """
400
156
        if not self._real_bzrdir:
401
 
            if 'hpssvfs' in debug.debug_flags:
402
 
                import traceback
403
 
                warning('VFS BzrDir access triggered\n%s',
404
 
                    ''.join(traceback.format_stack()))
405
 
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
157
            self._real_bzrdir = BzrDir.open_from_transport(
406
158
                self.root_transport, _server_formats=False)
407
159
            self._format._network_name = \
408
160
                self._real_bzrdir._format.network_name()
414
166
        # Prevent aliasing problems in the next_open_branch_result cache.
415
167
        # See create_branch for rationale.
416
168
        self._next_open_branch_result = None
417
 
        return _mod_bzrdir.BzrDir.break_lock(self)
 
169
        return BzrDir.break_lock(self)
418
170
 
419
171
    def _vfs_cloning_metadir(self, require_stacking=False):
420
172
        self._ensure_real()
451
203
        if len(branch_info) != 2:
452
204
            raise errors.UnexpectedSmartServerResponse(response)
453
205
        branch_ref, branch_name = branch_info
454
 
        format = controldir.network_format_registry.get(control_name)
 
206
        format = bzrdir.network_format_registry.get(control_name)
455
207
        if repo_name:
456
 
            format.repository_format = _mod_repository.network_format_registry.get(
 
208
            format.repository_format = repository.network_format_registry.get(
457
209
                repo_name)
458
210
        if branch_ref == 'ref':
459
211
            # XXX: we need possible_transports here to avoid reopening the
460
212
            # connection to the referenced location
461
 
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
 
213
            ref_bzrdir = BzrDir.open(branch_name)
462
214
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
463
215
            format.set_branch_format(branch_format)
464
216
        elif branch_ref == 'branch':
483
235
        self._ensure_real()
484
236
        self._real_bzrdir.destroy_repository()
485
237
 
486
 
    def create_branch(self, name=None, repository=None):
 
238
    def create_branch(self):
487
239
        # as per meta1 formats - just delegate to the format object which may
488
240
        # be parameterised.
489
 
        real_branch = self._format.get_branch_format().initialize(self,
490
 
            name=name, repository=repository)
 
241
        real_branch = self._format.get_branch_format().initialize(self)
491
242
        if not isinstance(real_branch, RemoteBranch):
492
 
            if not isinstance(repository, RemoteRepository):
493
 
                raise AssertionError(
494
 
                    'need a RemoteRepository to use with RemoteBranch, got %r'
495
 
                    % (repository,))
496
 
            result = RemoteBranch(self, repository, real_branch, name=name)
 
243
            result = RemoteBranch(self, self.find_repository(), real_branch)
497
244
        else:
498
245
            result = real_branch
499
246
        # BzrDir.clone_on_transport() uses the result of create_branch but does
505
252
        self._next_open_branch_result = result
506
253
        return result
507
254
 
508
 
    def destroy_branch(self, name=None):
 
255
    def destroy_branch(self):
509
256
        """See BzrDir.destroy_branch"""
510
257
        self._ensure_real()
511
 
        self._real_bzrdir.destroy_branch(name=name)
 
258
        self._real_bzrdir.destroy_branch()
512
259
        self._next_open_branch_result = None
513
260
 
514
 
    def create_workingtree(self, revision_id=None, from_branch=None,
515
 
        accelerator_tree=None, hardlink=False):
 
261
    def create_workingtree(self, revision_id=None, from_branch=None):
516
262
        raise errors.NotLocalUrl(self.transport.base)
517
263
 
518
 
    def find_branch_format(self, name=None):
 
264
    def find_branch_format(self):
519
265
        """Find the branch 'format' for this bzrdir.
520
266
 
521
267
        This might be a synthetic object for e.g. RemoteBranch and SVN.
522
268
        """
523
 
        b = self.open_branch(name=name)
 
269
        b = self.open_branch()
524
270
        return b._format
525
271
 
526
 
    def get_branch_reference(self, name=None):
 
272
    def get_branch_reference(self):
527
273
        """See BzrDir.get_branch_reference()."""
528
 
        if name is not None:
529
 
            # XXX JRV20100304: Support opening colocated branches
530
 
            raise errors.NoColocatedBranchSupport(self)
531
274
        response = self._get_branch_reference()
532
275
        if response[0] == 'ref':
533
276
            return response[1]
537
280
    def _get_branch_reference(self):
538
281
        path = self._path_for_remote_call(self._client)
539
282
        medium = self._client._medium
540
 
        candidate_calls = [
541
 
            ('BzrDir.open_branchV3', (2, 1)),
542
 
            ('BzrDir.open_branchV2', (1, 13)),
543
 
            ('BzrDir.open_branch', None),
544
 
            ]
545
 
        for verb, required_version in candidate_calls:
546
 
            if required_version and medium._is_remote_before(required_version):
547
 
                continue
 
283
        if not medium._is_remote_before((1, 13)):
548
284
            try:
549
 
                response = self._call(verb, path)
 
285
                response = self._call('BzrDir.open_branchV2', path)
 
286
                if response[0] not in ('ref', 'branch'):
 
287
                    raise errors.UnexpectedSmartServerResponse(response)
 
288
                return response
550
289
            except errors.UnknownSmartMethod:
551
 
                if required_version is None:
552
 
                    raise
553
 
                medium._remember_remote_is_before(required_version)
554
 
            else:
555
 
                break
556
 
        if verb == 'BzrDir.open_branch':
557
 
            if response[0] != 'ok':
558
 
                raise errors.UnexpectedSmartServerResponse(response)
559
 
            if response[1] != '':
560
 
                return ('ref', response[1])
561
 
            else:
562
 
                return ('branch', '')
563
 
        if response[0] not in ('ref', 'branch'):
 
290
                medium._remember_remote_is_before((1, 13))
 
291
        response = self._call('BzrDir.open_branch', path)
 
292
        if response[0] != 'ok':
564
293
            raise errors.UnexpectedSmartServerResponse(response)
565
 
        return response
 
294
        if response[1] != '':
 
295
            return ('ref', response[1])
 
296
        else:
 
297
            return ('branch', '')
566
298
 
567
 
    def _get_tree_branch(self, name=None):
 
299
    def _get_tree_branch(self):
568
300
        """See BzrDir._get_tree_branch()."""
569
 
        return None, self.open_branch(name=name)
 
301
        return None, self.open_branch()
570
302
 
571
 
    def open_branch(self, name=None, unsupported=False,
572
 
                    ignore_fallbacks=False):
573
 
        if unsupported:
 
303
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
304
        if _unsupported:
574
305
            raise NotImplementedError('unsupported flag support not implemented yet.')
575
306
        if self._next_open_branch_result is not None:
576
307
            # See create_branch for details.
581
312
        if response[0] == 'ref':
582
313
            # a branch reference, use the existing BranchReference logic.
583
314
            format = BranchReferenceFormat()
584
 
            return format.open(self, name=name, _found=True,
585
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
315
            return format.open(self, _found=True, location=response[1],
 
316
                ignore_fallbacks=ignore_fallbacks)
586
317
        branch_format_name = response[1]
587
318
        if not branch_format_name:
588
319
            branch_format_name = None
589
320
        format = RemoteBranchFormat(network_name=branch_format_name)
590
321
        return RemoteBranch(self, self.find_repository(), format=format,
591
 
            setup_stacking=not ignore_fallbacks, name=name)
 
322
            setup_stacking=not ignore_fallbacks)
592
323
 
593
324
    def _open_repo_v1(self, path):
594
325
        verb = 'BzrDir.find_repository'
671
402
        """Return the path to be used for this bzrdir in a remote call."""
672
403
        return client.remote_path_from_transport(self.root_transport)
673
404
 
674
 
    def get_branch_transport(self, branch_format, name=None):
 
405
    def get_branch_transport(self, branch_format):
675
406
        self._ensure_real()
676
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
407
        return self._real_bzrdir.get_branch_transport(branch_format)
677
408
 
678
409
    def get_repository_transport(self, repository_format):
679
410
        self._ensure_real()
687
418
        """Upgrading of remote bzrdirs is not supported yet."""
688
419
        return False
689
420
 
690
 
    def needs_format_conversion(self, format):
 
421
    def needs_format_conversion(self, format=None):
691
422
        """Upgrading of remote bzrdirs is not supported yet."""
 
423
        if format is None:
 
424
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
425
                % 'needs_format_conversion(format=None)')
692
426
        return False
693
427
 
694
428
    def clone(self, url, revision_id=None, force_new_repo=False,
701
435
        return RemoteBzrDirConfig(self)
702
436
 
703
437
 
704
 
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
 
438
class RemoteRepositoryFormat(repository.RepositoryFormat):
705
439
    """Format for repositories accessed over a _SmartClient.
706
440
 
707
441
    Instances of this repository are represented by RemoteRepository
722
456
    """
723
457
 
724
458
    _matchingbzrdir = RemoteBzrDirFormat()
725
 
    supports_full_versioned_files = True
726
 
    supports_leaving_lock = True
727
459
 
728
460
    def __init__(self):
729
 
        _mod_repository.RepositoryFormat.__init__(self)
 
461
        repository.RepositoryFormat.__init__(self)
730
462
        self._custom_format = None
731
463
        self._network_name = None
732
464
        self._creating_bzrdir = None
733
 
        self._revision_graph_can_have_wrong_parents = None
734
465
        self._supports_chks = None
735
466
        self._supports_external_lookups = None
736
467
        self._supports_tree_reference = None
737
 
        self._supports_funky_characters = None
738
468
        self._rich_root_data = None
739
469
 
740
470
    def __repr__(self):
769
499
        return self._supports_external_lookups
770
500
 
771
501
    @property
772
 
    def supports_funky_characters(self):
773
 
        if self._supports_funky_characters is None:
774
 
            self._ensure_real()
775
 
            self._supports_funky_characters = \
776
 
                self._custom_format.supports_funky_characters
777
 
        return self._supports_funky_characters
778
 
 
779
 
    @property
780
502
    def supports_tree_reference(self):
781
503
        if self._supports_tree_reference is None:
782
504
            self._ensure_real()
784
506
                self._custom_format.supports_tree_reference
785
507
        return self._supports_tree_reference
786
508
 
787
 
    @property
788
 
    def revision_graph_can_have_wrong_parents(self):
789
 
        if self._revision_graph_can_have_wrong_parents is None:
790
 
            self._ensure_real()
791
 
            self._revision_graph_can_have_wrong_parents = \
792
 
                self._custom_format.revision_graph_can_have_wrong_parents
793
 
        return self._revision_graph_can_have_wrong_parents
794
 
 
795
509
    def _vfs_initialize(self, a_bzrdir, shared):
796
510
        """Helper for common code in initialize."""
797
511
        if self._custom_format:
832
546
            network_name = self._network_name
833
547
        else:
834
548
            # Select the current bzrlib default and ask for that.
835
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
549
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
836
550
            reference_format = reference_bzrdir_format.repository_format
837
551
            network_name = reference_format.network_name()
838
552
        # 2) try direct creation via RPC
864
578
 
865
579
    def _ensure_real(self):
866
580
        if self._custom_format is None:
867
 
            self._custom_format = _mod_repository.network_format_registry.get(
 
581
            self._custom_format = repository.network_format_registry.get(
868
582
                self._network_name)
869
583
 
870
584
    @property
883
597
        return self._custom_format._fetch_reconcile
884
598
 
885
599
    def get_format_description(self):
886
 
        self._ensure_real()
887
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
600
        return 'bzr remote repository'
888
601
 
889
602
    def __eq__(self, other):
890
603
        return self.__class__ is other.__class__
906
619
        return self._custom_format._serializer
907
620
 
908
621
 
909
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
910
 
    controldir.ControlComponent):
 
622
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
911
623
    """Repository accessed over rpc.
912
624
 
913
625
    For the moment most operations are performed using local transport-backed
956
668
        # Additional places to query for data.
957
669
        self._fallback_repositories = []
958
670
 
959
 
    @property
960
 
    def user_transport(self):
961
 
        return self.bzrdir.user_transport
962
 
 
963
 
    @property
964
 
    def control_transport(self):
965
 
        # XXX: Normally you shouldn't directly get at the remote repository
966
 
        # transport, but I'm not sure it's worth making this method
967
 
        # optional -- mbp 2010-04-21
968
 
        return self.bzrdir.get_repository_transport(None)
969
 
 
970
671
    def __str__(self):
971
672
        return "%s(%s)" % (self.__class__.__name__, self.base)
972
673
 
1080
781
    def find_text_key_references(self):
1081
782
        """Find the text key references within the repository.
1082
783
 
 
784
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
785
        revision_ids. Each altered file-ids has the exact revision_ids that
 
786
        altered it listed explicitly.
1083
787
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1084
788
            to whether they were referred to by the inventory of the
1085
789
            revision_id that they contain. The inventory texts from all present
1103
807
        """Private method for using with old (< 1.2) servers to fallback."""
1104
808
        if revision_id is None:
1105
809
            revision_id = ''
1106
 
        elif _mod_revision.is_null(revision_id):
 
810
        elif revision.is_null(revision_id):
1107
811
            return {}
1108
812
 
1109
813
        path = self.bzrdir._path_for_remote_call(self._client)
1133
837
        return RemoteStreamSource(self, to_format)
1134
838
 
1135
839
    @needs_read_lock
1136
 
    def get_file_graph(self):
1137
 
        return graph.Graph(self.texts)
1138
 
 
1139
 
    @needs_read_lock
1140
840
    def has_revision(self, revision_id):
1141
841
        """True if this repository has a copy of the revision."""
1142
842
        # Copy of bzrlib.repository.Repository.has_revision
1159
859
    def _has_same_fallbacks(self, other_repo):
1160
860
        """Returns true if the repositories have the same fallbacks."""
1161
861
        # XXX: copied from Repository; it should be unified into a base class
1162
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
862
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
1163
863
        my_fb = self._fallback_repositories
1164
864
        other_fb = other_repo._fallback_repositories
1165
865
        if len(my_fb) != len(other_fb):
1181
881
        parents_provider = self._make_parents_provider(other_repository)
1182
882
        return graph.Graph(parents_provider)
1183
883
 
1184
 
    @needs_read_lock
1185
 
    def get_known_graph_ancestry(self, revision_ids):
1186
 
        """Return the known graph for a set of revision ids and their ancestors.
1187
 
        """
1188
 
        st = static_tuple.StaticTuple
1189
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
1190
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
1191
 
        return graph.GraphThunkIdsToKeys(known_graph)
1192
 
 
1193
884
    def gather_stats(self, revid=None, committers=None):
1194
885
        """See Repository.gather_stats()."""
1195
886
        path = self.bzrdir._path_for_remote_call(self._client)
1196
887
        # revid can be None to indicate no revisions, not just NULL_REVISION
1197
 
        if revid is None or _mod_revision.is_null(revid):
 
888
        if revid is None or revision.is_null(revid):
1198
889
            fmt_revid = ''
1199
890
        else:
1200
891
            fmt_revid = revid
1255
946
    def is_write_locked(self):
1256
947
        return self._lock_mode == 'w'
1257
948
 
1258
 
    def _warn_if_deprecated(self, branch=None):
1259
 
        # If we have a real repository, the check will be done there, if we
1260
 
        # don't the check will be done remotely.
1261
 
        pass
1262
 
 
1263
949
    def lock_read(self):
1264
 
        """Lock the repository for read operations.
1265
 
 
1266
 
        :return: A bzrlib.lock.LogicalLockResult.
1267
 
        """
1268
950
        # wrong eventually - want a local lock cache context
1269
951
        if not self._lock_mode:
1270
952
            self._note_lock('r')
1277
959
                repo.lock_read()
1278
960
        else:
1279
961
            self._lock_count += 1
1280
 
        return lock.LogicalLockResult(self.unlock)
1281
962
 
1282
963
    def _remote_lock_write(self, token):
1283
964
        path = self.bzrdir._path_for_remote_call(self._client)
1323
1004
            raise errors.ReadOnlyError(self)
1324
1005
        else:
1325
1006
            self._lock_count += 1
1326
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1007
        return self._lock_token or None
1327
1008
 
1328
1009
    def leave_lock_in_place(self):
1329
1010
        if not self._lock_token:
1483
1164
 
1484
1165
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1485
1166
                           timezone=None, committer=None, revprops=None,
1486
 
                           revision_id=None, lossy=False):
 
1167
                           revision_id=None):
1487
1168
        # FIXME: It ought to be possible to call this without immediately
1488
1169
        # triggering _ensure_real.  For now it's the easiest thing to do.
1489
1170
        self._ensure_real()
1490
1171
        real_repo = self._real_repository
1491
1172
        builder = real_repo.get_commit_builder(branch, parents,
1492
1173
                config, timestamp=timestamp, timezone=timezone,
1493
 
                committer=committer, revprops=revprops,
1494
 
                revision_id=revision_id, lossy=lossy)
 
1174
                committer=committer, revprops=revprops, revision_id=revision_id)
1495
1175
        return builder
1496
1176
 
1497
1177
    def add_fallback_repository(self, repository):
1510
1190
            # state, so always add a lock here. If a caller passes us a locked
1511
1191
            # repository, they are responsible for unlocking it later.
1512
1192
            repository.lock_read()
1513
 
        self._check_fallback_repository(repository)
1514
1193
        self._fallback_repositories.append(repository)
1515
1194
        # If self._real_repository was parameterised already (e.g. because a
1516
1195
        # _real_branch had its get_stacked_on_url method called), then the
1517
1196
        # repository to be added may already be in the _real_repositories list.
1518
1197
        if self._real_repository is not None:
1519
 
            fallback_locations = [repo.user_url for repo in
 
1198
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1520
1199
                self._real_repository._fallback_repositories]
1521
 
            if repository.user_url not in fallback_locations:
 
1200
            if repository.bzrdir.root_transport.base not in fallback_locations:
1522
1201
                self._real_repository.add_fallback_repository(repository)
1523
1202
 
1524
 
    def _check_fallback_repository(self, repository):
1525
 
        """Check that this repository can fallback to repository safely.
1526
 
 
1527
 
        Raise an error if not.
1528
 
 
1529
 
        :param repository: A repository to fallback to.
1530
 
        """
1531
 
        return _mod_repository.InterRepository._assert_same_model(
1532
 
            self, repository)
1533
 
 
1534
1203
    def add_inventory(self, revid, inv, parents):
1535
1204
        self._ensure_real()
1536
1205
        return self._real_repository.add_inventory(revid, inv, parents)
1537
1206
 
1538
1207
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1539
 
            parents, basis_inv=None, propagate_caches=False):
 
1208
                               parents):
1540
1209
        self._ensure_real()
1541
1210
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1542
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1543
 
            propagate_caches=propagate_caches)
 
1211
            delta, new_revision_id, parents)
1544
1212
 
1545
1213
    def add_revision(self, rev_id, rev, inv=None, config=None):
1546
1214
        self._ensure_real()
1576
1244
        return self._real_repository.make_working_trees()
1577
1245
 
1578
1246
    def refresh_data(self):
1579
 
        """Re-read any data needed to synchronise with disk.
 
1247
        """Re-read any data needed to to synchronise with disk.
1580
1248
 
1581
1249
        This method is intended to be called after another repository instance
1582
1250
        (such as one used by a smart server) has inserted data into the
1583
 
        repository. On all repositories this will work outside of write groups.
1584
 
        Some repository formats (pack and newer for bzrlib native formats)
1585
 
        support refresh_data inside write groups. If called inside a write
1586
 
        group on a repository that does not support refreshing in a write group
1587
 
        IsInWriteGroupError will be raised.
 
1251
        repository. It may not be called during a write group, but may be
 
1252
        called at any other time.
1588
1253
        """
 
1254
        if self.is_in_write_group():
 
1255
            raise errors.InternalBzrError(
 
1256
                "May not refresh_data while in a write group.")
1589
1257
        if self._real_repository is not None:
1590
1258
            self._real_repository.refresh_data()
1591
1259
 
1603
1271
        return result
1604
1272
 
1605
1273
    @needs_read_lock
1606
 
    def search_missing_revision_ids(self, other,
1607
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1608
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1609
 
            limit=None):
 
1274
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1610
1275
        """Return the revision ids that other has that this does not.
1611
1276
 
1612
1277
        These are returned in topological order.
1613
1278
 
1614
1279
        revision_id: only return revision ids included by revision_id.
1615
1280
        """
1616
 
        if symbol_versioning.deprecated_passed(revision_id):
1617
 
            symbol_versioning.warn(
1618
 
                'search_missing_revision_ids(revision_id=...) was '
1619
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
1620
 
                DeprecationWarning, stacklevel=2)
1621
 
            if revision_ids is not None:
1622
 
                raise AssertionError(
1623
 
                    'revision_ids is mutually exclusive with revision_id')
1624
 
            if revision_id is not None:
1625
 
                revision_ids = [revision_id]
1626
 
        inter_repo = _mod_repository.InterRepository.get(other, self)
1627
 
        return inter_repo.search_missing_revision_ids(
1628
 
            find_ghosts=find_ghosts, revision_ids=revision_ids,
1629
 
            if_present_ids=if_present_ids, limit=limit)
 
1281
        return repository.InterRepository.get(
 
1282
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
1630
1283
 
1631
 
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
1284
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1632
1285
            fetch_spec=None):
1633
1286
        # No base implementation to use as RemoteRepository is not a subclass
1634
1287
        # of Repository; so this is a copy of Repository.fetch().
1645
1298
            # check that last_revision is in 'from' and then return a
1646
1299
            # no-operation.
1647
1300
            if (revision_id is not None and
1648
 
                not _mod_revision.is_null(revision_id)):
 
1301
                not revision.is_null(revision_id)):
1649
1302
                self.get_revision(revision_id)
1650
1303
            return 0, []
1651
1304
        # if there is no specific appropriate InterRepository, this will get
1652
1305
        # the InterRepository base class, which raises an
1653
1306
        # IncompatibleRepositories when asked to fetch.
1654
 
        inter = _mod_repository.InterRepository.get(source, self)
1655
 
        return inter.fetch(revision_id=revision_id,
 
1307
        inter = repository.InterRepository.get(source, self)
 
1308
        return inter.fetch(revision_id=revision_id, pb=pb,
1656
1309
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1657
1310
 
1658
1311
    def create_bundle(self, target, base, fileobj, format=None):
1660
1313
        self._real_repository.create_bundle(target, base, fileobj, format)
1661
1314
 
1662
1315
    @needs_read_lock
1663
 
    @symbol_versioning.deprecated_method(
1664
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1665
1316
    def get_ancestry(self, revision_id, topo_sorted=True):
1666
1317
        self._ensure_real()
1667
1318
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1822
1473
        return self._real_repository.get_signature_text(revision_id)
1823
1474
 
1824
1475
    @needs_read_lock
1825
 
    def _get_inventory_xml(self, revision_id):
1826
 
        self._ensure_real()
1827
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1476
    def get_inventory_xml(self, revision_id):
 
1477
        self._ensure_real()
 
1478
        return self._real_repository.get_inventory_xml(revision_id)
 
1479
 
 
1480
    def deserialise_inventory(self, revision_id, xml):
 
1481
        self._ensure_real()
 
1482
        return self._real_repository.deserialise_inventory(revision_id, xml)
1828
1483
 
1829
1484
    def reconcile(self, other=None, thorough=False):
1830
1485
        self._ensure_real()
1884
1539
            tmpdir = osutils.mkdtemp()
1885
1540
            try:
1886
1541
                _extract_tar(tar, tmpdir)
1887
 
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
 
1542
                tmp_bzrdir = BzrDir.open(tmpdir)
1888
1543
                tmp_repo = tmp_bzrdir.open_repository()
1889
1544
                tmp_repo.copy_content_into(destination, revision_id)
1890
1545
            finally:
1906
1561
        return self._real_repository.inventories
1907
1562
 
1908
1563
    @needs_write_lock
1909
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1564
    def pack(self, hint=None):
1910
1565
        """Compress the data within the repository.
1911
1566
 
1912
1567
        This is not currently implemented within the smart server.
1913
1568
        """
1914
1569
        self._ensure_real()
1915
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1570
        return self._real_repository.pack(hint=hint)
1916
1571
 
1917
1572
    @property
1918
1573
    def revisions(self):
1975
1630
    def supports_rich_root(self):
1976
1631
        return self._format.rich_root_data
1977
1632
 
1978
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1979
1633
    def iter_reverse_revision_history(self, revision_id):
1980
1634
        self._ensure_real()
1981
1635
        return self._real_repository.iter_reverse_revision_history(revision_id)
2002
1656
        return self._real_repository.item_keys_introduced_by(revision_ids,
2003
1657
            _files_pb=_files_pb)
2004
1658
 
 
1659
    def revision_graph_can_have_wrong_parents(self):
 
1660
        # The answer depends on the remote repo format.
 
1661
        self._ensure_real()
 
1662
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
1663
 
2005
1664
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
2006
1665
        self._ensure_real()
2007
1666
        return self._real_repository._find_inconsistent_revision_parents(
2015
1674
        providers = [self._unstacked_provider]
2016
1675
        if other is not None:
2017
1676
            providers.insert(0, other)
2018
 
        return graph.StackedParentsProvider(_LazyListJoin(
2019
 
            providers, self._fallback_repositories))
 
1677
        providers.extend(r._make_parents_provider() for r in
 
1678
                         self._fallback_repositories)
 
1679
        return graph.StackedParentsProvider(providers)
2020
1680
 
2021
1681
    def _serialise_search_recipe(self, recipe):
2022
1682
        """Serialise a graph search recipe.
2030
1690
        return '\n'.join((start_keys, stop_keys, count))
2031
1691
 
2032
1692
    def _serialise_search_result(self, search_result):
2033
 
        parts = search_result.get_network_struct()
 
1693
        if isinstance(search_result, graph.PendingAncestryResult):
 
1694
            parts = ['ancestry-of']
 
1695
            parts.extend(search_result.heads)
 
1696
        else:
 
1697
            recipe = search_result.get_recipe()
 
1698
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
2034
1699
        return '\n'.join(parts)
2035
1700
 
2036
1701
    def autopack(self):
2046
1711
            raise errors.UnexpectedSmartServerResponse(response)
2047
1712
 
2048
1713
 
2049
 
class RemoteStreamSink(vf_repository.StreamSink):
 
1714
class RemoteStreamSink(repository.StreamSink):
2050
1715
 
2051
1716
    def _insert_real(self, stream, src_format, resume_tokens):
2052
1717
        self.target_repo._ensure_real()
2153
1818
        self._last_substream and self._last_stream so that the stream can be
2154
1819
        resumed by _resume_stream_with_vfs.
2155
1820
        """
2156
 
 
 
1821
                    
2157
1822
        stream_iter = iter(stream)
2158
1823
        for substream_kind, substream in stream_iter:
2159
1824
            if substream_kind == 'inventory-deltas':
2162
1827
                return
2163
1828
            else:
2164
1829
                yield substream_kind, substream
2165
 
 
2166
 
 
2167
 
class RemoteStreamSource(vf_repository.StreamSource):
 
1830
            
 
1831
 
 
1832
class RemoteStreamSource(repository.StreamSource):
2168
1833
    """Stream data from a remote server."""
2169
1834
 
2170
1835
    def get_stream(self, search):
2230
1895
        candidate_verbs = [
2231
1896
            ('Repository.get_stream_1.19', (1, 19)),
2232
1897
            ('Repository.get_stream', (1, 13))]
2233
 
 
2234
1898
        found_verb = False
2235
1899
        for verb, version in candidate_verbs:
2236
1900
            if medium._is_remote_before(version):
2240
1904
                    verb, args, search_bytes)
2241
1905
            except errors.UnknownSmartMethod:
2242
1906
                medium._remember_remote_is_before(version)
2243
 
            except errors.UnknownErrorFromSmartServer, e:
2244
 
                if isinstance(search, graph.EverythingResult):
2245
 
                    error_verb = e.error_from_smart_server.error_verb
2246
 
                    if error_verb == 'BadSearch':
2247
 
                        # Pre-2.4 servers don't support this sort of search.
2248
 
                        # XXX: perhaps falling back to VFS on BadSearch is a
2249
 
                        # good idea in general?  It might provide a little bit
2250
 
                        # of protection against client-side bugs.
2251
 
                        medium._remember_remote_is_before((2, 4))
2252
 
                        break
2253
 
                raise
2254
1907
            else:
2255
1908
                response_tuple, response_handler = response
2256
1909
                found_verb = True
2260
1913
        if response_tuple[0] != 'ok':
2261
1914
            raise errors.UnexpectedSmartServerResponse(response_tuple)
2262
1915
        byte_stream = response_handler.read_streamed_body()
2263
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
2264
 
            self._record_counter)
 
1916
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
2265
1917
        if src_format.network_name() != repo._format.network_name():
2266
1918
            raise AssertionError(
2267
1919
                "Mismatched RemoteRepository and stream src %r, %r" % (
2343
1995
                self._network_name)
2344
1996
 
2345
1997
    def get_format_description(self):
2346
 
        self._ensure_real()
2347
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
1998
        return 'Remote BZR Branch'
2348
1999
 
2349
2000
    def network_name(self):
2350
2001
        return self._network_name
2351
2002
 
2352
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2353
 
        return a_bzrdir.open_branch(name=name, 
2354
 
            ignore_fallbacks=ignore_fallbacks)
 
2003
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
2004
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2355
2005
 
2356
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2006
    def _vfs_initialize(self, a_bzrdir):
2357
2007
        # Initialisation when using a local bzrdir object, or a non-vfs init
2358
2008
        # method is not available on the server.
2359
2009
        # self._custom_format is always set - the start of initialize ensures
2360
2010
        # that.
2361
2011
        if isinstance(a_bzrdir, RemoteBzrDir):
2362
2012
            a_bzrdir._ensure_real()
2363
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2364
 
                name)
 
2013
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2365
2014
        else:
2366
2015
            # We assume the bzrdir is parameterised; it may not be.
2367
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2016
            result = self._custom_format.initialize(a_bzrdir)
2368
2017
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2369
2018
            not isinstance(result, RemoteBranch)):
2370
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2371
 
                                  name=name)
 
2019
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2372
2020
        return result
2373
2021
 
2374
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
2022
    def initialize(self, a_bzrdir):
2375
2023
        # 1) get the network name to use.
2376
2024
        if self._custom_format:
2377
2025
            network_name = self._custom_format.network_name()
2378
2026
        else:
2379
2027
            # Select the current bzrlib default and ask for that.
2380
 
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
2028
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
2381
2029
            reference_format = reference_bzrdir_format.get_branch_format()
2382
2030
            self._custom_format = reference_format
2383
2031
            network_name = reference_format.network_name()
2384
2032
        # Being asked to create on a non RemoteBzrDir:
2385
2033
        if not isinstance(a_bzrdir, RemoteBzrDir):
2386
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2034
            return self._vfs_initialize(a_bzrdir)
2387
2035
        medium = a_bzrdir._client._medium
2388
2036
        if medium._is_remote_before((1, 13)):
2389
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2037
            return self._vfs_initialize(a_bzrdir)
2390
2038
        # Creating on a remote bzr dir.
2391
2039
        # 2) try direct creation via RPC
2392
2040
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2393
 
        if name is not None:
2394
 
            # XXX JRV20100304: Support creating colocated branches
2395
 
            raise errors.NoColocatedBranchSupport(self)
2396
2041
        verb = 'BzrDir.create_branch'
2397
2042
        try:
2398
2043
            response = a_bzrdir._call(verb, path, network_name)
2399
2044
        except errors.UnknownSmartMethod:
2400
2045
            # Fallback - use vfs methods
2401
2046
            medium._remember_remote_is_before((1, 13))
2402
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2047
            return self._vfs_initialize(a_bzrdir)
2403
2048
        if response[0] != 'ok':
2404
2049
            raise errors.UnexpectedSmartServerResponse(response)
2405
2050
        # Turn the response into a RemoteRepository object.
2406
2051
        format = RemoteBranchFormat(network_name=response[1])
2407
2052
        repo_format = response_tuple_to_repo_format(response[3:])
2408
 
        repo_path = response[2]
2409
 
        if repository is not None:
2410
 
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
2411
 
            url_diff = urlutils.relative_url(repository.user_url,
2412
 
                    remote_repo_url)
2413
 
            if url_diff != '.':
2414
 
                raise AssertionError(
2415
 
                    'repository.user_url %r does not match URL from server '
2416
 
                    'response (%r + %r)'
2417
 
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
2418
 
            remote_repo = repository
 
2053
        if response[2] == '':
 
2054
            repo_bzrdir = a_bzrdir
2419
2055
        else:
2420
 
            if repo_path == '':
2421
 
                repo_bzrdir = a_bzrdir
2422
 
            else:
2423
 
                repo_bzrdir = RemoteBzrDir(
2424
 
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
2425
 
                    a_bzrdir._client)
2426
 
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2056
            repo_bzrdir = RemoteBzrDir(
 
2057
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
 
2058
                a_bzrdir._client)
 
2059
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2427
2060
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2428
 
            format=format, setup_stacking=False, name=name)
 
2061
            format=format, setup_stacking=False)
2429
2062
        # XXX: We know this is a new branch, so it must have revno 0, revid
2430
2063
        # NULL_REVISION. Creating the branch locked would make this be unable
2431
2064
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2450
2083
        self._ensure_real()
2451
2084
        return self._custom_format.supports_set_append_revisions_only()
2452
2085
 
2453
 
    def _use_default_local_heads_to_fetch(self):
2454
 
        # If the branch format is a metadir format *and* its heads_to_fetch
2455
 
        # implementation is not overridden vs the base class, we can use the
2456
 
        # base class logic rather than use the heads_to_fetch RPC.  This is
2457
 
        # usually cheaper in terms of net round trips, as the last-revision and
2458
 
        # tags info fetched is cached and would be fetched anyway.
2459
 
        self._ensure_real()
2460
 
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
2461
 
            branch_class = self._custom_format._branch_class()
2462
 
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
2463
 
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
2464
 
                return True
2465
 
        return False
2466
2086
 
2467
2087
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2468
2088
    """Branch stored on a server accessed by HPSS RPC.
2471
2091
    """
2472
2092
 
2473
2093
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2474
 
        _client=None, format=None, setup_stacking=True, name=None):
 
2094
        _client=None, format=None, setup_stacking=True):
2475
2095
        """Create a RemoteBranch instance.
2476
2096
 
2477
2097
        :param real_branch: An optional local implementation of the branch
2483
2103
        :param setup_stacking: If True make an RPC call to determine the
2484
2104
            stacked (or not) status of the branch. If False assume the branch
2485
2105
            is not stacked.
2486
 
        :param name: Colocated branch name
2487
2106
        """
2488
2107
        # We intentionally don't call the parent class's __init__, because it
2489
2108
        # will try to assign to self.tags, which is a property in this subclass.
2508
2127
            self._real_branch = None
2509
2128
        # Fill out expected attributes of branch for bzrlib API users.
2510
2129
        self._clear_cached_state()
2511
 
        # TODO: deprecate self.base in favor of user_url
2512
 
        self.base = self.bzrdir.user_url
2513
 
        self._name = name
 
2130
        self.base = self.bzrdir.root_transport.base
2514
2131
        self._control_files = None
2515
2132
        self._lock_mode = None
2516
2133
        self._lock_token = None
2581
2198
                    'to use vfs implementation')
2582
2199
            self.bzrdir._ensure_real()
2583
2200
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2584
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
2201
                ignore_fallbacks=self._real_ignore_fallbacks)
2585
2202
            if self.repository._real_repository is None:
2586
2203
                # Give the remote repository the matching real repo.
2587
2204
                real_repo = self._real_branch.repository
2667
2284
            self._is_stacked = False
2668
2285
        else:
2669
2286
            self._is_stacked = True
2670
 
 
 
2287
        
2671
2288
    def _vfs_get_tags_bytes(self):
2672
2289
        self._ensure_real()
2673
2290
        return self._real_branch._get_tags_bytes()
2674
2291
 
2675
 
    @needs_read_lock
2676
2292
    def _get_tags_bytes(self):
2677
 
        if self._tags_bytes is None:
2678
 
            self._tags_bytes = self._get_tags_bytes_via_hpss()
2679
 
        return self._tags_bytes
2680
 
 
2681
 
    def _get_tags_bytes_via_hpss(self):
2682
2293
        medium = self._client._medium
2683
2294
        if medium._is_remote_before((1, 13)):
2684
2295
            return self._vfs_get_tags_bytes()
2694
2305
        return self._real_branch._set_tags_bytes(bytes)
2695
2306
 
2696
2307
    def _set_tags_bytes(self, bytes):
2697
 
        if self.is_locked():
2698
 
            self._tags_bytes = bytes
2699
2308
        medium = self._client._medium
2700
2309
        if medium._is_remote_before((1, 18)):
2701
2310
            self._vfs_set_tags_bytes(bytes)
2710
2319
            self._vfs_set_tags_bytes(bytes)
2711
2320
 
2712
2321
    def lock_read(self):
2713
 
        """Lock the branch for read operations.
2714
 
 
2715
 
        :return: A bzrlib.lock.LogicalLockResult.
2716
 
        """
2717
2322
        self.repository.lock_read()
2718
2323
        if not self._lock_mode:
2719
2324
            self._note_lock('r')
2723
2328
                self._real_branch.lock_read()
2724
2329
        else:
2725
2330
            self._lock_count += 1
2726
 
        return lock.LogicalLockResult(self.unlock)
2727
2331
 
2728
2332
    def _remote_lock_write(self, token):
2729
2333
        if token is None:
2730
2334
            branch_token = repo_token = ''
2731
2335
        else:
2732
2336
            branch_token = token
2733
 
            repo_token = self.repository.lock_write().repository_token
 
2337
            repo_token = self.repository.lock_write()
2734
2338
            self.repository.unlock()
2735
2339
        err_context = {'token': token}
2736
 
        try:
2737
 
            response = self._call(
2738
 
                'Branch.lock_write', self._remote_path(), branch_token,
2739
 
                repo_token or '', **err_context)
2740
 
        except errors.LockContention, e:
2741
 
            # The LockContention from the server doesn't have any
2742
 
            # information about the lock_url. We re-raise LockContention
2743
 
            # with valid lock_url.
2744
 
            raise errors.LockContention('(remote lock)',
2745
 
                self.repository.base.split('.bzr/')[0])
 
2340
        response = self._call(
 
2341
            'Branch.lock_write', self._remote_path(), branch_token,
 
2342
            repo_token or '', **err_context)
2746
2343
        if response[0] != 'ok':
2747
2344
            raise errors.UnexpectedSmartServerResponse(response)
2748
2345
        ok, branch_token, repo_token = response
2769
2366
            self._lock_mode = 'w'
2770
2367
            self._lock_count = 1
2771
2368
        elif self._lock_mode == 'r':
2772
 
            raise errors.ReadOnlyError(self)
 
2369
            raise errors.ReadOnlyTransaction
2773
2370
        else:
2774
2371
            if token is not None:
2775
2372
                # A token was given to lock_write, and we're relocking, so
2780
2377
            self._lock_count += 1
2781
2378
            # Re-lock the repository too.
2782
2379
            self.repository.lock_write(self._repo_lock_token)
2783
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2380
        return self._lock_token or None
2784
2381
 
2785
2382
    def _unlock(self, branch_token, repo_token):
2786
2383
        err_context = {'token': str((branch_token, repo_token))}
2837
2434
            raise NotImplementedError(self.dont_leave_lock_in_place)
2838
2435
        self._leave_lock = False
2839
2436
 
2840
 
    @needs_read_lock
2841
2437
    def get_rev_id(self, revno, history=None):
2842
2438
        if revno == 0:
2843
2439
            return _mod_revision.NULL_REVISION
2855
2451
            missing_parent = parent_map[missing_parent]
2856
2452
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2857
2453
 
2858
 
    def _read_last_revision_info(self):
 
2454
    def _last_revision_info(self):
2859
2455
        response = self._call('Branch.last_revision_info', self._remote_path())
2860
2456
        if response[0] != 'ok':
2861
2457
            raise SmartProtocolError('unexpected response code %s' % (response,))
2924
2520
            raise errors.UnexpectedSmartServerResponse(response)
2925
2521
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2926
2522
 
2927
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2928
2523
    @needs_write_lock
2929
2524
    def set_revision_history(self, rev_history):
2930
 
        """See Branch.set_revision_history."""
2931
 
        self._set_revision_history(rev_history)
2932
 
 
2933
 
    @needs_write_lock
2934
 
    def _set_revision_history(self, rev_history):
2935
2525
        # Send just the tip revision of the history; the server will generate
2936
2526
        # the full history from that.  If the revision doesn't exist in this
2937
2527
        # branch, NoSuchRevision will be raised.
2995
2585
            _override_hook_target=self, **kwargs)
2996
2586
 
2997
2587
    @needs_read_lock
2998
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
 
2588
    def push(self, target, overwrite=False, stop_revision=None):
2999
2589
        self._ensure_real()
3000
2590
        return self._real_branch.push(
3001
 
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
 
2591
            target, overwrite=overwrite, stop_revision=stop_revision,
3002
2592
            _override_hook_source_branch=self)
3003
2593
 
3004
2594
    def is_locked(self):
3014
2604
        # XXX: These should be returned by the set_last_revision_info verb
3015
2605
        old_revno, old_revid = self.last_revision_info()
3016
2606
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
3017
 
        if not revision_id or not isinstance(revision_id, basestring):
3018
 
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2607
        revision_id = ensure_null(revision_id)
3019
2608
        try:
3020
2609
            response = self._call('Branch.set_last_revision_info',
3021
2610
                self._remote_path(), self._lock_token, self._repo_lock_token,
3050
2639
            except errors.UnknownSmartMethod:
3051
2640
                medium._remember_remote_is_before((1, 6))
3052
2641
        self._clear_cached_state_of_remote_branch_only()
3053
 
        self._set_revision_history(self._lefthand_history(revision_id,
 
2642
        self.set_revision_history(self._lefthand_history(revision_id,
3054
2643
            last_rev=last_rev,other_branch=other_branch))
3055
2644
 
3056
2645
    def set_push_location(self, location):
3057
2646
        self._ensure_real()
3058
2647
        return self._real_branch.set_push_location(location)
3059
2648
 
3060
 
    def heads_to_fetch(self):
3061
 
        if self._format._use_default_local_heads_to_fetch():
3062
 
            # We recognise this format, and its heads-to-fetch implementation
3063
 
            # is the default one (tip + tags).  In this case it's cheaper to
3064
 
            # just use the default implementation rather than a special RPC as
3065
 
            # the tip and tags data is cached.
3066
 
            return branch.Branch.heads_to_fetch(self)
3067
 
        medium = self._client._medium
3068
 
        if medium._is_remote_before((2, 4)):
3069
 
            return self._vfs_heads_to_fetch()
3070
 
        try:
3071
 
            return self._rpc_heads_to_fetch()
3072
 
        except errors.UnknownSmartMethod:
3073
 
            medium._remember_remote_is_before((2, 4))
3074
 
            return self._vfs_heads_to_fetch()
3075
 
 
3076
 
    def _rpc_heads_to_fetch(self):
3077
 
        response = self._call('Branch.heads_to_fetch', self._remote_path())
3078
 
        if len(response) != 2:
3079
 
            raise errors.UnexpectedSmartServerResponse(response)
3080
 
        must_fetch, if_present_fetch = response
3081
 
        return set(must_fetch), set(if_present_fetch)
3082
 
 
3083
 
    def _vfs_heads_to_fetch(self):
3084
 
        self._ensure_real()
3085
 
        return self._real_branch.heads_to_fetch()
3086
 
 
3087
2649
 
3088
2650
class RemoteConfig(object):
3089
2651
    """A Config that reads and writes from smart verbs.
3103
2665
        """
3104
2666
        try:
3105
2667
            configobj = self._get_configobj()
3106
 
            section_obj = None
3107
2668
            if section is None:
3108
2669
                section_obj = configobj
3109
2670
            else:
3110
2671
                try:
3111
2672
                    section_obj = configobj[section]
3112
2673
                except KeyError:
3113
 
                    pass
3114
 
            if section_obj is None:
3115
 
                value = default
3116
 
            else:
3117
 
                value = section_obj.get(name, default)
 
2674
                    return default
 
2675
            return section_obj.get(name, default)
3118
2676
        except errors.UnknownSmartMethod:
3119
 
            value = self._vfs_get_option(name, section, default)
3120
 
        for hook in config.OldConfigHooks['get']:
3121
 
            hook(self, name, value)
3122
 
        return value
 
2677
            return self._vfs_get_option(name, section, default)
3123
2678
 
3124
2679
    def _response_to_configobj(self, response):
3125
2680
        if len(response[0]) and response[0][0] != 'ok':
3126
2681
            raise errors.UnexpectedSmartServerResponse(response)
3127
2682
        lines = response[1].read_body_bytes().splitlines()
3128
 
        conf = config.ConfigObj(lines, encoding='utf-8')
3129
 
        for hook in config.OldConfigHooks['load']:
3130
 
            hook(self)
3131
 
        return conf
 
2683
        return config.ConfigObj(lines, encoding='utf-8')
3132
2684
 
3133
2685
 
3134
2686
class RemoteBranchConfig(RemoteConfig):
3153
2705
        medium = self._branch._client._medium
3154
2706
        if medium._is_remote_before((1, 14)):
3155
2707
            return self._vfs_set_option(value, name, section)
3156
 
        if isinstance(value, dict):
3157
 
            if medium._is_remote_before((2, 2)):
3158
 
                return self._vfs_set_option(value, name, section)
3159
 
            return self._set_config_option_dict(value, name, section)
3160
 
        else:
3161
 
            return self._set_config_option(value, name, section)
3162
 
 
3163
 
    def _set_config_option(self, value, name, section):
3164
2708
        try:
3165
2709
            path = self._branch._remote_path()
3166
2710
            response = self._branch._client.call('Branch.set_config_option',
3167
2711
                path, self._branch._lock_token, self._branch._repo_lock_token,
3168
2712
                value.encode('utf8'), name, section or '')
3169
2713
        except errors.UnknownSmartMethod:
3170
 
            medium = self._branch._client._medium
3171
2714
            medium._remember_remote_is_before((1, 14))
3172
2715
            return self._vfs_set_option(value, name, section)
3173
2716
        if response != ():
3174
2717
            raise errors.UnexpectedSmartServerResponse(response)
3175
2718
 
3176
 
    def _serialize_option_dict(self, option_dict):
3177
 
        utf8_dict = {}
3178
 
        for key, value in option_dict.items():
3179
 
            if isinstance(key, unicode):
3180
 
                key = key.encode('utf8')
3181
 
            if isinstance(value, unicode):
3182
 
                value = value.encode('utf8')
3183
 
            utf8_dict[key] = value
3184
 
        return bencode.bencode(utf8_dict)
3185
 
 
3186
 
    def _set_config_option_dict(self, value, name, section):
3187
 
        try:
3188
 
            path = self._branch._remote_path()
3189
 
            serialised_dict = self._serialize_option_dict(value)
3190
 
            response = self._branch._client.call(
3191
 
                'Branch.set_config_option_dict',
3192
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
3193
 
                serialised_dict, name, section or '')
3194
 
        except errors.UnknownSmartMethod:
3195
 
            medium = self._branch._client._medium
3196
 
            medium._remember_remote_is_before((2, 2))
3197
 
            return self._vfs_set_option(value, name, section)
3198
 
        if response != ():
3199
 
            raise errors.UnexpectedSmartServerResponse(response)
3200
 
 
3201
2719
    def _real_object(self):
3202
2720
        self._branch._ensure_real()
3203
2721
        return self._branch._real_branch
3286
2804
                    'Missing key %r in context %r', key_err.args[0], context)
3287
2805
                raise err
3288
2806
 
3289
 
    if err.error_verb == 'NoSuchRevision':
 
2807
    if err.error_verb == 'IncompatibleRepositories':
 
2808
        raise errors.IncompatibleRepositories(err.error_args[0],
 
2809
            err.error_args[1], err.error_args[2])
 
2810
    elif err.error_verb == 'NoSuchRevision':
3290
2811
        raise NoSuchRevision(find('branch'), err.error_args[0])
3291
2812
    elif err.error_verb == 'nosuchrevision':
3292
2813
        raise NoSuchRevision(find('repository'), err.error_args[0])
3293
 
    elif err.error_verb == 'nobranch':
3294
 
        if len(err.error_args) >= 1:
3295
 
            extra = err.error_args[0]
3296
 
        else:
3297
 
            extra = None
3298
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3299
 
            detail=extra)
 
2814
    elif err.error_tuple == ('nobranch',):
 
2815
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
3300
2816
    elif err.error_verb == 'norepository':
3301
2817
        raise errors.NoRepositoryPresent(find('bzrdir'))
 
2818
    elif err.error_verb == 'LockContention':
 
2819
        raise errors.LockContention('(remote lock)')
3302
2820
    elif err.error_verb == 'UnlockableTransport':
3303
2821
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
 
2822
    elif err.error_verb == 'LockFailed':
 
2823
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3304
2824
    elif err.error_verb == 'TokenMismatch':
3305
2825
        raise errors.TokenMismatch(find('token'), '(remote token)')
3306
2826
    elif err.error_verb == 'Diverged':
3307
2827
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
 
2828
    elif err.error_verb == 'TipChangeRejected':
 
2829
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
2830
    elif err.error_verb == 'UnstackableBranchFormat':
 
2831
        raise errors.UnstackableBranchFormat(*err.error_args)
 
2832
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
2833
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3308
2834
    elif err.error_verb == 'NotStacked':
3309
2835
        raise errors.NotStacked(branch=find('branch'))
3310
2836
    elif err.error_verb == 'PermissionDenied':
3320
2846
    elif err.error_verb == 'NoSuchFile':
3321
2847
        path = get_path()
3322
2848
        raise errors.NoSuchFile(path)
3323
 
    _translate_error_without_context(err)
3324
 
 
3325
 
 
3326
 
def _translate_error_without_context(err):
3327
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3328
 
    if err.error_verb == 'IncompatibleRepositories':
3329
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3330
 
            err.error_args[1], err.error_args[2])
3331
 
    elif err.error_verb == 'LockContention':
3332
 
        raise errors.LockContention('(remote lock)')
3333
 
    elif err.error_verb == 'LockFailed':
3334
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3335
 
    elif err.error_verb == 'TipChangeRejected':
3336
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3337
 
    elif err.error_verb == 'UnstackableBranchFormat':
3338
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3339
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3340
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3341
2849
    elif err.error_verb == 'FileExists':
3342
2850
        raise errors.FileExists(err.error_args[0])
3343
2851
    elif err.error_verb == 'DirectoryNotEmpty':
3362
2870
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3363
2871
    elif err.error_verb == 'ReadOnlyError':
3364
2872
        raise errors.TransportNotPossible('readonly transport')
3365
 
    elif err.error_verb == 'MemoryError':
3366
 
        raise errors.BzrError("remote server out of memory\n"
3367
 
            "Retry non-remotely, or contact the server admin for details.")
3368
2873
    raise errors.UnknownErrorFromSmartServer(err)