← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import bz2
 
20
import zlib
18
21
 
19
22
from bzrlib import (
20
23
    bencode,
21
24
    branch,
22
 
    bzrdir,
 
25
    bzrdir as _mod_bzrdir,
23
26
    config,
 
27
    controldir,
24
28
    debug,
25
29
    errors,
 
30
    gpg,
26
31
    graph,
 
32
    inventory_delta,
27
33
    lock,
28
34
    lockdir,
29
 
    repository,
30
 
    revision,
 
35
    osutils,
 
36
    registry,
 
37
    repository as _mod_repository,
31
38
    revision as _mod_revision,
 
39
    static_tuple,
32
40
    symbol_versioning,
33
 
)
34
 
from bzrlib.branch import BranchReferenceFormat
35
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
41
    testament as _mod_testament,
 
42
    urlutils,
 
43
    vf_repository,
 
44
    vf_search,
 
45
    )
 
46
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
36
47
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
37
48
from bzrlib.errors import (
38
49
    NoSuchRevision,
39
50
    SmartProtocolError,
40
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
41
54
from bzrlib.lockable_files import LockableFiles
42
55
from bzrlib.smart import client, vfs, repository as smart_repo
43
 
from bzrlib.revision import ensure_null, NULL_REVISION
44
 
from bzrlib.trace import mutter, note, warning
 
56
from bzrlib.smart.client import _SmartClient
 
57
from bzrlib.revision import NULL_REVISION
 
58
from bzrlib.revisiontree import InventoryRevisionTree
 
59
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
60
from bzrlib.serializer import format_registry as serializer_format_registry
 
61
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
62
 
 
63
 
 
64
_DEFAULT_SEARCH_DEPTH = 100
45
65
 
46
66
 
47
67
class _RpcHelper(object):
84
104
    return format
85
105
 
86
106
 
87
 
# Note: RemoteBzrDirFormat is in bzrdir.py
88
 
 
89
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
107
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
108
# does not have to be imported unless a remote format is involved.
 
109
 
 
110
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
111
    """Format representing bzrdirs accessed via a smart server"""
 
112
 
 
113
    supports_workingtrees = False
 
114
 
 
115
    def __init__(self):
 
116
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
117
        # XXX: It's a bit ugly that the network name is here, because we'd
 
118
        # like to believe that format objects are stateless or at least
 
119
        # immutable,  However, we do at least avoid mutating the name after
 
120
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
121
        self._network_name = None
 
122
 
 
123
    def __repr__(self):
 
124
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
125
            self._network_name)
 
126
 
 
127
    def get_format_description(self):
 
128
        if self._network_name:
 
129
            try:
 
130
                real_format = controldir.network_format_registry.get(
 
131
                        self._network_name)
 
132
            except KeyError:
 
133
                pass
 
134
            else:
 
135
                return 'Remote: ' + real_format.get_format_description()
 
136
        return 'bzr remote bzrdir'
 
137
 
 
138
    def get_format_string(self):
 
139
        raise NotImplementedError(self.get_format_string)
 
140
 
 
141
    def network_name(self):
 
142
        if self._network_name:
 
143
            return self._network_name
 
144
        else:
 
145
            raise AssertionError("No network name set.")
 
146
 
 
147
    def initialize_on_transport(self, transport):
 
148
        try:
 
149
            # hand off the request to the smart server
 
150
            client_medium = transport.get_smart_medium()
 
151
        except errors.NoSmartMedium:
 
152
            # TODO: lookup the local format from a server hint.
 
153
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
154
            return local_dir_format.initialize_on_transport(transport)
 
155
        client = _SmartClient(client_medium)
 
156
        path = client.remote_path_from_transport(transport)
 
157
        try:
 
158
            response = client.call('BzrDirFormat.initialize', path)
 
159
        except errors.ErrorFromSmartServer, err:
 
160
            _translate_error(err, path=path)
 
161
        if response[0] != 'ok':
 
162
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
163
        format = RemoteBzrDirFormat()
 
164
        self._supply_sub_formats_to(format)
 
165
        return RemoteBzrDir(transport, format)
 
166
 
 
167
    def parse_NoneTrueFalse(self, arg):
 
168
        if not arg:
 
169
            return None
 
170
        if arg == 'False':
 
171
            return False
 
172
        if arg == 'True':
 
173
            return True
 
174
        raise AssertionError("invalid arg %r" % arg)
 
175
 
 
176
    def _serialize_NoneTrueFalse(self, arg):
 
177
        if arg is False:
 
178
            return 'False'
 
179
        if arg:
 
180
            return 'True'
 
181
        return ''
 
182
 
 
183
    def _serialize_NoneString(self, arg):
 
184
        return arg or ''
 
185
 
 
186
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
187
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
188
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
189
        shared_repo=False):
 
190
        try:
 
191
            # hand off the request to the smart server
 
192
            client_medium = transport.get_smart_medium()
 
193
        except errors.NoSmartMedium:
 
194
            do_vfs = True
 
195
        else:
 
196
            # Decline to open it if the server doesn't support our required
 
197
            # version (3) so that the VFS-based transport will do it.
 
198
            if client_medium.should_probe():
 
199
                try:
 
200
                    server_version = client_medium.protocol_version()
 
201
                    if server_version != '2':
 
202
                        do_vfs = True
 
203
                    else:
 
204
                        do_vfs = False
 
205
                except errors.SmartProtocolError:
 
206
                    # Apparently there's no usable smart server there, even though
 
207
                    # the medium supports the smart protocol.
 
208
                    do_vfs = True
 
209
            else:
 
210
                do_vfs = False
 
211
        if not do_vfs:
 
212
            client = _SmartClient(client_medium)
 
213
            path = client.remote_path_from_transport(transport)
 
214
            if client_medium._is_remote_before((1, 16)):
 
215
                do_vfs = True
 
216
        if do_vfs:
 
217
            # TODO: lookup the local format from a server hint.
 
218
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
219
            self._supply_sub_formats_to(local_dir_format)
 
220
            return local_dir_format.initialize_on_transport_ex(transport,
 
221
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
222
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
223
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
224
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
225
                vfs_only=True)
 
226
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
227
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
228
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
229
 
 
230
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
231
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
232
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
233
        args = []
 
234
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
235
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
236
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
237
        args.append(self._serialize_NoneString(stacked_on))
 
238
        # stack_on_pwd is often/usually our transport
 
239
        if stack_on_pwd:
 
240
            try:
 
241
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
242
                if not stack_on_pwd:
 
243
                    stack_on_pwd = '.'
 
244
            except errors.PathNotChild:
 
245
                pass
 
246
        args.append(self._serialize_NoneString(stack_on_pwd))
 
247
        args.append(self._serialize_NoneString(repo_format_name))
 
248
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
249
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
250
        request_network_name = self._network_name or \
 
251
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
252
        try:
 
253
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
254
                request_network_name, path, *args)
 
255
        except errors.UnknownSmartMethod:
 
256
            client._medium._remember_remote_is_before((1,16))
 
257
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
258
            self._supply_sub_formats_to(local_dir_format)
 
259
            return local_dir_format.initialize_on_transport_ex(transport,
 
260
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
261
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
262
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
263
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
264
                vfs_only=True)
 
265
        except errors.ErrorFromSmartServer, err:
 
266
            _translate_error(err, path=path)
 
267
        repo_path = response[0]
 
268
        bzrdir_name = response[6]
 
269
        require_stacking = response[7]
 
270
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
271
        format = RemoteBzrDirFormat()
 
272
        format._network_name = bzrdir_name
 
273
        self._supply_sub_formats_to(format)
 
274
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
275
        if repo_path:
 
276
            repo_format = response_tuple_to_repo_format(response[1:])
 
277
            if repo_path == '.':
 
278
                repo_path = ''
 
279
            if repo_path:
 
280
                repo_bzrdir_format = RemoteBzrDirFormat()
 
281
                repo_bzrdir_format._network_name = response[5]
 
282
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
283
                    repo_bzrdir_format)
 
284
            else:
 
285
                repo_bzr = bzrdir
 
286
            final_stack = response[8] or None
 
287
            final_stack_pwd = response[9] or None
 
288
            if final_stack_pwd:
 
289
                final_stack_pwd = urlutils.join(
 
290
                    transport.base, final_stack_pwd)
 
291
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
292
            if len(response) > 10:
 
293
                # Updated server verb that locks remotely.
 
294
                repo_lock_token = response[10] or None
 
295
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
296
                if repo_lock_token:
 
297
                    remote_repo.dont_leave_lock_in_place()
 
298
            else:
 
299
                remote_repo.lock_write()
 
300
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
301
                final_stack_pwd, require_stacking)
 
302
            policy.acquire_repository()
 
303
        else:
 
304
            remote_repo = None
 
305
            policy = None
 
306
        bzrdir._format.set_branch_format(self.get_branch_format())
 
307
        if require_stacking:
 
308
            # The repo has already been created, but we need to make sure that
 
309
            # we'll make a stackable branch.
 
310
            bzrdir._format.require_stacking(_skip_repo=True)
 
311
        return remote_repo, bzrdir, require_stacking, policy
 
312
 
 
313
    def _open(self, transport):
 
314
        return RemoteBzrDir(transport, self)
 
315
 
 
316
    def __eq__(self, other):
 
317
        if not isinstance(other, RemoteBzrDirFormat):
 
318
            return False
 
319
        return self.get_format_description() == other.get_format_description()
 
320
 
 
321
    def __return_repository_format(self):
 
322
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
323
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
324
        # that it should use that for init() etc.
 
325
        result = RemoteRepositoryFormat()
 
326
        custom_format = getattr(self, '_repository_format', None)
 
327
        if custom_format:
 
328
            if isinstance(custom_format, RemoteRepositoryFormat):
 
329
                return custom_format
 
330
            else:
 
331
                # We will use the custom format to create repositories over the
 
332
                # wire; expose its details like rich_root_data for code to
 
333
                # query
 
334
                result._custom_format = custom_format
 
335
        return result
 
336
 
 
337
    def get_branch_format(self):
 
338
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
339
        if not isinstance(result, RemoteBranchFormat):
 
340
            new_result = RemoteBranchFormat()
 
341
            new_result._custom_format = result
 
342
            # cache the result
 
343
            self.set_branch_format(new_result)
 
344
            result = new_result
 
345
        return result
 
346
 
 
347
    repository_format = property(__return_repository_format,
 
348
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
349
 
 
350
 
 
351
class RemoteControlStore(config.IniFileStore):
 
352
    """Control store which attempts to use HPSS calls to retrieve control store.
 
353
 
 
354
    Note that this is specific to bzr-based formats.
 
355
    """
 
356
 
 
357
    def __init__(self, bzrdir):
 
358
        super(RemoteControlStore, self).__init__()
 
359
        self.bzrdir = bzrdir
 
360
        self._real_store = None
 
361
 
 
362
    def lock_write(self, token=None):
 
363
        self._ensure_real()
 
364
        return self._real_store.lock_write(token)
 
365
 
 
366
    def unlock(self):
 
367
        self._ensure_real()
 
368
        return self._real_store.unlock()
 
369
 
 
370
    @needs_write_lock
 
371
    def save(self):
 
372
        # We need to be able to override the undecorated implementation
 
373
        self.save_without_locking()
 
374
 
 
375
    def save_without_locking(self):
 
376
        super(RemoteControlStore, self).save()
 
377
 
 
378
    def _ensure_real(self):
 
379
        self.bzrdir._ensure_real()
 
380
        if self._real_store is None:
 
381
            self._real_store = config.ControlStore(self.bzrdir)
 
382
 
 
383
    def external_url(self):
 
384
        return self.bzrdir.user_url
 
385
 
 
386
    def _load_content(self):
 
387
        medium = self.bzrdir._client._medium
 
388
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
389
        try:
 
390
            response, handler = self.bzrdir._call_expecting_body(
 
391
                'BzrDir.get_config_file', path)
 
392
        except errors.UnknownSmartMethod:
 
393
            self._ensure_real()
 
394
            return self._real_store._load_content()
 
395
        if len(response) and response[0] != 'ok':
 
396
            raise errors.UnexpectedSmartServerResponse(response)
 
397
        return handler.read_body_bytes()
 
398
 
 
399
    def _save_content(self, content):
 
400
        # FIXME JRV 2011-11-22: Ideally this should use a
 
401
        # HPSS call too, but at the moment it is not possible
 
402
        # to write lock control directories.
 
403
        self._ensure_real()
 
404
        return self._real_store._save_content(content)
 
405
 
 
406
 
 
407
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
90
408
    """Control directory on a remote server, accessed via bzr:// or similar."""
91
409
 
92
410
    def __init__(self, transport, format, _client=None, _force_probe=False):
95
413
        :param _client: Private parameter for testing. Disables probing and the
96
414
            use of a real bzrdir.
97
415
        """
98
 
        BzrDir.__init__(self, transport, format)
 
416
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
99
417
        # this object holds a delegated bzrdir that uses file-level operations
100
418
        # to talk to the other side
101
419
        self._real_bzrdir = None
114
432
 
115
433
        self._probe_bzrdir()
116
434
 
 
435
    def __repr__(self):
 
436
        return '%s(%r)' % (self.__class__.__name__, self._client)
 
437
 
117
438
    def _probe_bzrdir(self):
118
439
        medium = self._client._medium
119
440
        path = self._path_for_remote_call(self._client)
158
479
                import traceback
159
480
                warning('VFS BzrDir access triggered\n%s',
160
481
                    ''.join(traceback.format_stack()))
161
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
482
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
162
483
                self.root_transport, _server_formats=False)
163
484
            self._format._network_name = \
164
485
                self._real_bzrdir._format.network_name()
170
491
        # Prevent aliasing problems in the next_open_branch_result cache.
171
492
        # See create_branch for rationale.
172
493
        self._next_open_branch_result = None
173
 
        return BzrDir.break_lock(self)
 
494
        return _mod_bzrdir.BzrDir.break_lock(self)
 
495
 
 
496
    def _vfs_checkout_metadir(self):
 
497
        self._ensure_real()
 
498
        return self._real_bzrdir.checkout_metadir()
 
499
 
 
500
    def checkout_metadir(self):
 
501
        """Retrieve the controldir format to use for checkouts of this one.
 
502
        """
 
503
        medium = self._client._medium
 
504
        if medium._is_remote_before((2, 5)):
 
505
            return self._vfs_checkout_metadir()
 
506
        path = self._path_for_remote_call(self._client)
 
507
        try:
 
508
            response = self._client.call('BzrDir.checkout_metadir',
 
509
                path)
 
510
        except errors.UnknownSmartMethod:
 
511
            medium._remember_remote_is_before((2, 5))
 
512
            return self._vfs_checkout_metadir()
 
513
        if len(response) != 3:
 
514
            raise errors.UnexpectedSmartServerResponse(response)
 
515
        control_name, repo_name, branch_name = response
 
516
        try:
 
517
            format = controldir.network_format_registry.get(control_name)
 
518
        except KeyError:
 
519
            raise errors.UnknownFormatError(kind='control',
 
520
                format=control_name)
 
521
        if repo_name:
 
522
            try:
 
523
                repo_format = _mod_repository.network_format_registry.get(
 
524
                    repo_name)
 
525
            except KeyError:
 
526
                raise errors.UnknownFormatError(kind='repository',
 
527
                    format=repo_name)
 
528
            format.repository_format = repo_format
 
529
        if branch_name:
 
530
            try:
 
531
                format.set_branch_format(
 
532
                    branch.network_format_registry.get(branch_name))
 
533
            except KeyError:
 
534
                raise errors.UnknownFormatError(kind='branch',
 
535
                    format=branch_name)
 
536
        return format
174
537
 
175
538
    def _vfs_cloning_metadir(self, require_stacking=False):
176
539
        self._ensure_real()
207
570
        if len(branch_info) != 2:
208
571
            raise errors.UnexpectedSmartServerResponse(response)
209
572
        branch_ref, branch_name = branch_info
210
 
        format = bzrdir.network_format_registry.get(control_name)
 
573
        try:
 
574
            format = controldir.network_format_registry.get(control_name)
 
575
        except KeyError:
 
576
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
577
 
211
578
        if repo_name:
212
 
            format.repository_format = repository.network_format_registry.get(
213
 
                repo_name)
 
579
            try:
 
580
                format.repository_format = _mod_repository.network_format_registry.get(
 
581
                    repo_name)
 
582
            except KeyError:
 
583
                raise errors.UnknownFormatError(kind='repository',
 
584
                    format=repo_name)
214
585
        if branch_ref == 'ref':
215
586
            # XXX: we need possible_transports here to avoid reopening the
216
587
            # connection to the referenced location
217
 
            ref_bzrdir = BzrDir.open(branch_name)
 
588
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
218
589
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
219
590
            format.set_branch_format(branch_format)
220
591
        elif branch_ref == 'branch':
221
592
            if branch_name:
222
 
                format.set_branch_format(
223
 
                    branch.network_format_registry.get(branch_name))
 
593
                try:
 
594
                    branch_format = branch.network_format_registry.get(
 
595
                        branch_name)
 
596
                except KeyError:
 
597
                    raise errors.UnknownFormatError(kind='branch',
 
598
                        format=branch_name)
 
599
                format.set_branch_format(branch_format)
224
600
        else:
225
601
            raise errors.UnexpectedSmartServerResponse(response)
226
602
        return format
236
612
 
237
613
    def destroy_repository(self):
238
614
        """See BzrDir.destroy_repository"""
239
 
        self._ensure_real()
240
 
        self._real_bzrdir.destroy_repository()
 
615
        path = self._path_for_remote_call(self._client)
 
616
        try:
 
617
            response = self._call('BzrDir.destroy_repository', path)
 
618
        except errors.UnknownSmartMethod:
 
619
            self._ensure_real()
 
620
            self._real_bzrdir.destroy_repository()
 
621
            return
 
622
        if response[0] != 'ok':
 
623
            raise SmartProtocolError('unexpected response code %s' % (response,))
241
624
 
242
 
    def create_branch(self):
 
625
    def create_branch(self, name=None, repository=None,
 
626
                      append_revisions_only=None):
243
627
        # as per meta1 formats - just delegate to the format object which may
244
628
        # be parameterised.
245
 
        real_branch = self._format.get_branch_format().initialize(self)
 
629
        real_branch = self._format.get_branch_format().initialize(self,
 
630
            name=name, repository=repository,
 
631
            append_revisions_only=append_revisions_only)
246
632
        if not isinstance(real_branch, RemoteBranch):
247
 
            result = RemoteBranch(self, self.find_repository(), real_branch)
 
633
            if not isinstance(repository, RemoteRepository):
 
634
                raise AssertionError(
 
635
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
636
                    % (repository,))
 
637
            result = RemoteBranch(self, repository, real_branch, name=name)
248
638
        else:
249
639
            result = real_branch
250
640
        # BzrDir.clone_on_transport() uses the result of create_branch but does
256
646
        self._next_open_branch_result = result
257
647
        return result
258
648
 
259
 
    def destroy_branch(self):
 
649
    def destroy_branch(self, name=None):
260
650
        """See BzrDir.destroy_branch"""
261
 
        self._ensure_real()
262
 
        self._real_bzrdir.destroy_branch()
 
651
        path = self._path_for_remote_call(self._client)
 
652
        try:
 
653
            if name is not None:
 
654
                args = (name, )
 
655
            else:
 
656
                args = ()
 
657
            response = self._call('BzrDir.destroy_branch', path, *args)
 
658
        except errors.UnknownSmartMethod:
 
659
            self._ensure_real()
 
660
            self._real_bzrdir.destroy_branch(name=name)
 
661
            self._next_open_branch_result = None
 
662
            return
263
663
        self._next_open_branch_result = None
 
664
        if response[0] != 'ok':
 
665
            raise SmartProtocolError('unexpected response code %s' % (response,))
264
666
 
265
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
667
    def create_workingtree(self, revision_id=None, from_branch=None,
 
668
        accelerator_tree=None, hardlink=False):
266
669
        raise errors.NotLocalUrl(self.transport.base)
267
670
 
268
 
    def find_branch_format(self):
 
671
    def find_branch_format(self, name=None):
269
672
        """Find the branch 'format' for this bzrdir.
270
673
 
271
674
        This might be a synthetic object for e.g. RemoteBranch and SVN.
272
675
        """
273
 
        b = self.open_branch()
 
676
        b = self.open_branch(name=name)
274
677
        return b._format
275
678
 
276
 
    def get_branch_reference(self):
 
679
    def get_branch_reference(self, name=None):
277
680
        """See BzrDir.get_branch_reference()."""
 
681
        if name is not None:
 
682
            # XXX JRV20100304: Support opening colocated branches
 
683
            raise errors.NoColocatedBranchSupport(self)
278
684
        response = self._get_branch_reference()
279
685
        if response[0] == 'ref':
280
686
            return response[1]
284
690
    def _get_branch_reference(self):
285
691
        path = self._path_for_remote_call(self._client)
286
692
        medium = self._client._medium
287
 
        if not medium._is_remote_before((1, 13)):
 
693
        candidate_calls = [
 
694
            ('BzrDir.open_branchV3', (2, 1)),
 
695
            ('BzrDir.open_branchV2', (1, 13)),
 
696
            ('BzrDir.open_branch', None),
 
697
            ]
 
698
        for verb, required_version in candidate_calls:
 
699
            if required_version and medium._is_remote_before(required_version):
 
700
                continue
288
701
            try:
289
 
                response = self._call('BzrDir.open_branchV2', path)
290
 
                if response[0] not in ('ref', 'branch'):
291
 
                    raise errors.UnexpectedSmartServerResponse(response)
292
 
                return response
 
702
                response = self._call(verb, path)
293
703
            except errors.UnknownSmartMethod:
294
 
                medium._remember_remote_is_before((1, 13))
295
 
        response = self._call('BzrDir.open_branch', path)
296
 
        if response[0] != 'ok':
 
704
                if required_version is None:
 
705
                    raise
 
706
                medium._remember_remote_is_before(required_version)
 
707
            else:
 
708
                break
 
709
        if verb == 'BzrDir.open_branch':
 
710
            if response[0] != 'ok':
 
711
                raise errors.UnexpectedSmartServerResponse(response)
 
712
            if response[1] != '':
 
713
                return ('ref', response[1])
 
714
            else:
 
715
                return ('branch', '')
 
716
        if response[0] not in ('ref', 'branch'):
297
717
            raise errors.UnexpectedSmartServerResponse(response)
298
 
        if response[1] != '':
299
 
            return ('ref', response[1])
300
 
        else:
301
 
            return ('branch', '')
 
718
        return response
302
719
 
303
 
    def _get_tree_branch(self):
 
720
    def _get_tree_branch(self, name=None):
304
721
        """See BzrDir._get_tree_branch()."""
305
 
        return None, self.open_branch()
 
722
        return None, self.open_branch(name=name)
306
723
 
307
 
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
308
 
        if _unsupported:
 
724
    def open_branch(self, name=None, unsupported=False,
 
725
                    ignore_fallbacks=False, possible_transports=None):
 
726
        if unsupported:
309
727
            raise NotImplementedError('unsupported flag support not implemented yet.')
310
728
        if self._next_open_branch_result is not None:
311
729
            # See create_branch for details.
316
734
        if response[0] == 'ref':
317
735
            # a branch reference, use the existing BranchReference logic.
318
736
            format = BranchReferenceFormat()
319
 
            return format.open(self, _found=True, location=response[1],
320
 
                ignore_fallbacks=ignore_fallbacks)
 
737
            return format.open(self, name=name, _found=True,
 
738
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
739
                possible_transports=possible_transports)
321
740
        branch_format_name = response[1]
322
741
        if not branch_format_name:
323
742
            branch_format_name = None
324
743
        format = RemoteBranchFormat(network_name=branch_format_name)
325
744
        return RemoteBranch(self, self.find_repository(), format=format,
326
 
            setup_stacking=not ignore_fallbacks)
 
745
            setup_stacking=not ignore_fallbacks, name=name,
 
746
            possible_transports=possible_transports)
327
747
 
328
748
    def _open_repo_v1(self, path):
329
749
        verb = 'BzrDir.find_repository'
392
812
 
393
813
    def has_workingtree(self):
394
814
        if self._has_working_tree is None:
395
 
            self._ensure_real()
396
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
815
            path = self._path_for_remote_call(self._client)
 
816
            try:
 
817
                response = self._call('BzrDir.has_workingtree', path)
 
818
            except errors.UnknownSmartMethod:
 
819
                self._ensure_real()
 
820
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
821
            else:
 
822
                if response[0] not in ('yes', 'no'):
 
823
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
824
                self._has_working_tree = (response[0] == 'yes')
397
825
        return self._has_working_tree
398
826
 
399
827
    def open_workingtree(self, recommend_upgrade=True):
404
832
 
405
833
    def _path_for_remote_call(self, client):
406
834
        """Return the path to be used for this bzrdir in a remote call."""
407
 
        return client.remote_path_from_transport(self.root_transport)
 
835
        return urlutils.split_segment_parameters_raw(
 
836
            client.remote_path_from_transport(self.root_transport))[0]
408
837
 
409
 
    def get_branch_transport(self, branch_format):
 
838
    def get_branch_transport(self, branch_format, name=None):
410
839
        self._ensure_real()
411
 
        return self._real_bzrdir.get_branch_transport(branch_format)
 
840
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
412
841
 
413
842
    def get_repository_transport(self, repository_format):
414
843
        self._ensure_real()
422
851
        """Upgrading of remote bzrdirs is not supported yet."""
423
852
        return False
424
853
 
425
 
    def needs_format_conversion(self, format=None):
 
854
    def needs_format_conversion(self, format):
426
855
        """Upgrading of remote bzrdirs is not supported yet."""
427
 
        if format is None:
428
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
429
 
                % 'needs_format_conversion(format=None)')
430
856
        return False
431
857
 
432
 
    def clone(self, url, revision_id=None, force_new_repo=False,
433
 
              preserve_stacking=False):
434
 
        self._ensure_real()
435
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
436
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
437
 
 
438
858
    def _get_config(self):
439
859
        return RemoteBzrDirConfig(self)
440
860
 
441
 
 
442
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
861
    def _get_config_store(self):
 
862
        return RemoteControlStore(self)
 
863
 
 
864
 
 
865
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
443
866
    """Format for repositories accessed over a _SmartClient.
444
867
 
445
868
    Instances of this repository are represented by RemoteRepository
460
883
    """
461
884
 
462
885
    _matchingbzrdir = RemoteBzrDirFormat()
 
886
    supports_full_versioned_files = True
 
887
    supports_leaving_lock = True
463
888
 
464
889
    def __init__(self):
465
 
        repository.RepositoryFormat.__init__(self)
 
890
        _mod_repository.RepositoryFormat.__init__(self)
466
891
        self._custom_format = None
467
892
        self._network_name = None
468
893
        self._creating_bzrdir = None
 
894
        self._revision_graph_can_have_wrong_parents = None
469
895
        self._supports_chks = None
470
896
        self._supports_external_lookups = None
471
897
        self._supports_tree_reference = None
 
898
        self._supports_funky_characters = None
 
899
        self._supports_nesting_repositories = None
472
900
        self._rich_root_data = None
473
901
 
474
902
    def __repr__(self):
503
931
        return self._supports_external_lookups
504
932
 
505
933
    @property
 
934
    def supports_funky_characters(self):
 
935
        if self._supports_funky_characters is None:
 
936
            self._ensure_real()
 
937
            self._supports_funky_characters = \
 
938
                self._custom_format.supports_funky_characters
 
939
        return self._supports_funky_characters
 
940
 
 
941
    @property
 
942
    def supports_nesting_repositories(self):
 
943
        if self._supports_nesting_repositories is None:
 
944
            self._ensure_real()
 
945
            self._supports_nesting_repositories = \
 
946
                self._custom_format.supports_nesting_repositories
 
947
        return self._supports_nesting_repositories
 
948
 
 
949
    @property
506
950
    def supports_tree_reference(self):
507
951
        if self._supports_tree_reference is None:
508
952
            self._ensure_real()
510
954
                self._custom_format.supports_tree_reference
511
955
        return self._supports_tree_reference
512
956
 
 
957
    @property
 
958
    def revision_graph_can_have_wrong_parents(self):
 
959
        if self._revision_graph_can_have_wrong_parents is None:
 
960
            self._ensure_real()
 
961
            self._revision_graph_can_have_wrong_parents = \
 
962
                self._custom_format.revision_graph_can_have_wrong_parents
 
963
        return self._revision_graph_can_have_wrong_parents
 
964
 
513
965
    def _vfs_initialize(self, a_bzrdir, shared):
514
966
        """Helper for common code in initialize."""
515
967
        if self._custom_format:
550
1002
            network_name = self._network_name
551
1003
        else:
552
1004
            # Select the current bzrlib default and ask for that.
553
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1005
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
554
1006
            reference_format = reference_bzrdir_format.repository_format
555
1007
            network_name = reference_format.network_name()
556
1008
        # 2) try direct creation via RPC
582
1034
 
583
1035
    def _ensure_real(self):
584
1036
        if self._custom_format is None:
585
 
            self._custom_format = repository.network_format_registry.get(
586
 
                self._network_name)
 
1037
            try:
 
1038
                self._custom_format = _mod_repository.network_format_registry.get(
 
1039
                    self._network_name)
 
1040
            except KeyError:
 
1041
                raise errors.UnknownFormatError(kind='repository',
 
1042
                    format=self._network_name)
587
1043
 
588
1044
    @property
589
1045
    def _fetch_order(self):
624
1080
        return self._custom_format._serializer
625
1081
 
626
1082
 
627
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
 
1083
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1084
        lock._RelockDebugMixin):
628
1085
    """Repository accessed over rpc.
629
1086
 
630
1087
    For the moment most operations are performed using local transport-backed
654
1111
        self._format = format
655
1112
        self._lock_mode = None
656
1113
        self._lock_token = None
 
1114
        self._write_group_tokens = None
657
1115
        self._lock_count = 0
658
1116
        self._leave_lock = False
659
1117
        # Cache of revision parents; misses are cached during read locks, and
673
1131
        # Additional places to query for data.
674
1132
        self._fallback_repositories = []
675
1133
 
 
1134
    @property
 
1135
    def user_transport(self):
 
1136
        return self.bzrdir.user_transport
 
1137
 
 
1138
    @property
 
1139
    def control_transport(self):
 
1140
        # XXX: Normally you shouldn't directly get at the remote repository
 
1141
        # transport, but I'm not sure it's worth making this method
 
1142
        # optional -- mbp 2010-04-21
 
1143
        return self.bzrdir.get_repository_transport(None)
 
1144
 
676
1145
    def __str__(self):
677
1146
        return "%s(%s)" % (self.__class__.__name__, self.base)
678
1147
 
688
1157
 
689
1158
        :param suppress_errors: see Repository.abort_write_group.
690
1159
        """
691
 
        self._ensure_real()
692
 
        return self._real_repository.abort_write_group(
693
 
            suppress_errors=suppress_errors)
 
1160
        if self._real_repository:
 
1161
            self._ensure_real()
 
1162
            return self._real_repository.abort_write_group(
 
1163
                suppress_errors=suppress_errors)
 
1164
        if not self.is_in_write_group():
 
1165
            if suppress_errors:
 
1166
                mutter('(suppressed) not in write group')
 
1167
                return
 
1168
            raise errors.BzrError("not in write group")
 
1169
        path = self.bzrdir._path_for_remote_call(self._client)
 
1170
        try:
 
1171
            response = self._call('Repository.abort_write_group', path,
 
1172
                self._lock_token, self._write_group_tokens)
 
1173
        except Exception, exc:
 
1174
            self._write_group = None
 
1175
            if not suppress_errors:
 
1176
                raise
 
1177
            mutter('abort_write_group failed')
 
1178
            log_exception_quietly()
 
1179
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1180
        else:
 
1181
            if response != ('ok', ):
 
1182
                raise errors.UnexpectedSmartServerResponse(response)
 
1183
            self._write_group_tokens = None
694
1184
 
695
1185
    @property
696
1186
    def chk_bytes(self):
710
1200
        for older plugins that don't use e.g. the CommitBuilder
711
1201
        facility.
712
1202
        """
713
 
        self._ensure_real()
714
 
        return self._real_repository.commit_write_group()
 
1203
        if self._real_repository:
 
1204
            self._ensure_real()
 
1205
            return self._real_repository.commit_write_group()
 
1206
        if not self.is_in_write_group():
 
1207
            raise errors.BzrError("not in write group")
 
1208
        path = self.bzrdir._path_for_remote_call(self._client)
 
1209
        response = self._call('Repository.commit_write_group', path,
 
1210
            self._lock_token, self._write_group_tokens)
 
1211
        if response != ('ok', ):
 
1212
            raise errors.UnexpectedSmartServerResponse(response)
 
1213
        self._write_group_tokens = None
715
1214
 
716
1215
    def resume_write_group(self, tokens):
717
 
        self._ensure_real()
718
 
        return self._real_repository.resume_write_group(tokens)
 
1216
        if self._real_repository:
 
1217
            return self._real_repository.resume_write_group(tokens)
 
1218
        path = self.bzrdir._path_for_remote_call(self._client)
 
1219
        try:
 
1220
            response = self._call('Repository.check_write_group', path,
 
1221
               self._lock_token, tokens)
 
1222
        except errors.UnknownSmartMethod:
 
1223
            self._ensure_real()
 
1224
            return self._real_repository.resume_write_group(tokens)
 
1225
        if response != ('ok', ):
 
1226
            raise errors.UnexpectedSmartServerResponse(response)
 
1227
        self._write_group_tokens = tokens
719
1228
 
720
1229
    def suspend_write_group(self):
721
 
        self._ensure_real()
722
 
        return self._real_repository.suspend_write_group()
 
1230
        if self._real_repository:
 
1231
            return self._real_repository.suspend_write_group()
 
1232
        ret = self._write_group_tokens or []
 
1233
        self._write_group_tokens = None
 
1234
        return ret
723
1235
 
724
1236
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
725
1237
        self._ensure_real()
786
1298
    def find_text_key_references(self):
787
1299
        """Find the text key references within the repository.
788
1300
 
789
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
790
 
        revision_ids. Each altered file-ids has the exact revision_ids that
791
 
        altered it listed explicitly.
792
1301
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
793
1302
            to whether they were referred to by the inventory of the
794
1303
            revision_id that they contain. The inventory texts from all present
812
1321
        """Private method for using with old (< 1.2) servers to fallback."""
813
1322
        if revision_id is None:
814
1323
            revision_id = ''
815
 
        elif revision.is_null(revision_id):
 
1324
        elif _mod_revision.is_null(revision_id):
816
1325
            return {}
817
1326
 
818
1327
        path = self.bzrdir._path_for_remote_call(self._client)
842
1351
        return RemoteStreamSource(self, to_format)
843
1352
 
844
1353
    @needs_read_lock
 
1354
    def get_file_graph(self):
 
1355
        return graph.Graph(self.texts)
 
1356
 
 
1357
    @needs_read_lock
845
1358
    def has_revision(self, revision_id):
846
1359
        """True if this repository has a copy of the revision."""
847
1360
        # Copy of bzrlib.repository.Repository.has_revision
864
1377
    def _has_same_fallbacks(self, other_repo):
865
1378
        """Returns true if the repositories have the same fallbacks."""
866
1379
        # XXX: copied from Repository; it should be unified into a base class
867
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1380
        # <https://bugs.launchpad.net/bzr/+bug/401622>
868
1381
        my_fb = self._fallback_repositories
869
1382
        other_fb = other_repo._fallback_repositories
870
1383
        if len(my_fb) != len(other_fb):
886
1399
        parents_provider = self._make_parents_provider(other_repository)
887
1400
        return graph.Graph(parents_provider)
888
1401
 
 
1402
    @needs_read_lock
 
1403
    def get_known_graph_ancestry(self, revision_ids):
 
1404
        """Return the known graph for a set of revision ids and their ancestors.
 
1405
        """
 
1406
        st = static_tuple.StaticTuple
 
1407
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
1408
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
 
1409
        return graph.GraphThunkIdsToKeys(known_graph)
 
1410
 
889
1411
    def gather_stats(self, revid=None, committers=None):
890
1412
        """See Repository.gather_stats()."""
891
1413
        path = self.bzrdir._path_for_remote_call(self._client)
892
1414
        # revid can be None to indicate no revisions, not just NULL_REVISION
893
 
        if revid is None or revision.is_null(revid):
 
1415
        if revid is None or _mod_revision.is_null(revid):
894
1416
            fmt_revid = ''
895
1417
        else:
896
1418
            fmt_revid = revid
925
1447
 
926
1448
    def get_physical_lock_status(self):
927
1449
        """See Repository.get_physical_lock_status()."""
928
 
        # should be an API call to the server.
929
 
        self._ensure_real()
930
 
        return self._real_repository.get_physical_lock_status()
 
1450
        path = self.bzrdir._path_for_remote_call(self._client)
 
1451
        try:
 
1452
            response = self._call('Repository.get_physical_lock_status', path)
 
1453
        except errors.UnknownSmartMethod:
 
1454
            self._ensure_real()
 
1455
            return self._real_repository.get_physical_lock_status()
 
1456
        if response[0] not in ('yes', 'no'):
 
1457
            raise errors.UnexpectedSmartServerResponse(response)
 
1458
        return (response[0] == 'yes')
931
1459
 
932
1460
    def is_in_write_group(self):
933
1461
        """Return True if there is an open write group.
934
1462
 
935
1463
        write groups are only applicable locally for the smart server..
936
1464
        """
 
1465
        if self._write_group_tokens is not None:
 
1466
            return True
937
1467
        if self._real_repository:
938
1468
            return self._real_repository.is_in_write_group()
939
1469
 
951
1481
    def is_write_locked(self):
952
1482
        return self._lock_mode == 'w'
953
1483
 
 
1484
    def _warn_if_deprecated(self, branch=None):
 
1485
        # If we have a real repository, the check will be done there, if we
 
1486
        # don't the check will be done remotely.
 
1487
        pass
 
1488
 
954
1489
    def lock_read(self):
 
1490
        """Lock the repository for read operations.
 
1491
 
 
1492
        :return: A bzrlib.lock.LogicalLockResult.
 
1493
        """
955
1494
        # wrong eventually - want a local lock cache context
956
1495
        if not self._lock_mode:
957
1496
            self._note_lock('r')
964
1503
                repo.lock_read()
965
1504
        else:
966
1505
            self._lock_count += 1
 
1506
        return lock.LogicalLockResult(self.unlock)
967
1507
 
968
1508
    def _remote_lock_write(self, token):
969
1509
        path = self.bzrdir._path_for_remote_call(self._client)
1009
1549
            raise errors.ReadOnlyError(self)
1010
1550
        else:
1011
1551
            self._lock_count += 1
1012
 
        return self._lock_token or None
 
1552
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1013
1553
 
1014
1554
    def leave_lock_in_place(self):
1015
1555
        if not self._lock_token:
1064
1604
            self._real_repository.lock_write(self._lock_token)
1065
1605
        elif self._lock_mode == 'r':
1066
1606
            self._real_repository.lock_read()
 
1607
        if self._write_group_tokens is not None:
 
1608
            # if we are already in a write group, resume it
 
1609
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1610
            self._write_group_tokens = None
1067
1611
 
1068
1612
    def start_write_group(self):
1069
1613
        """Start a write group on the decorated repository.
1073
1617
        for older plugins that don't use e.g. the CommitBuilder
1074
1618
        facility.
1075
1619
        """
1076
 
        self._ensure_real()
1077
 
        return self._real_repository.start_write_group()
 
1620
        if self._real_repository:
 
1621
            self._ensure_real()
 
1622
            return self._real_repository.start_write_group()
 
1623
        if not self.is_write_locked():
 
1624
            raise errors.NotWriteLocked(self)
 
1625
        if self._write_group_tokens is not None:
 
1626
            raise errors.BzrError('already in a write group')
 
1627
        path = self.bzrdir._path_for_remote_call(self._client)
 
1628
        try:
 
1629
            response = self._call('Repository.start_write_group', path,
 
1630
                self._lock_token)
 
1631
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1632
            self._ensure_real()
 
1633
            return self._real_repository.start_write_group()
 
1634
        if response[0] != 'ok':
 
1635
            raise errors.UnexpectedSmartServerResponse(response)
 
1636
        self._write_group_tokens = response[1]
1078
1637
 
1079
1638
    def _unlock(self, token):
1080
1639
        path = self.bzrdir._path_for_remote_call(self._client)
1107
1666
            # This is just to let the _real_repository stay up to date.
1108
1667
            if self._real_repository is not None:
1109
1668
                self._real_repository.unlock()
 
1669
            elif self._write_group_tokens is not None:
 
1670
                self.abort_write_group()
1110
1671
        finally:
1111
1672
            # The rpc-level lock should be released even if there was a
1112
1673
            # problem releasing the vfs-based lock.
1124
1685
 
1125
1686
    def break_lock(self):
1126
1687
        # should hand off to the network
1127
 
        self._ensure_real()
1128
 
        return self._real_repository.break_lock()
 
1688
        path = self.bzrdir._path_for_remote_call(self._client)
 
1689
        try:
 
1690
            response = self._call("Repository.break_lock", path)
 
1691
        except errors.UnknownSmartMethod:
 
1692
            self._ensure_real()
 
1693
            return self._real_repository.break_lock()
 
1694
        if response != ('ok',):
 
1695
            raise errors.UnexpectedSmartServerResponse(response)
1129
1696
 
1130
1697
    def _get_tarball(self, compression):
1131
1698
        """Return a TemporaryFile containing a repository tarball.
1149
1716
            return t
1150
1717
        raise errors.UnexpectedSmartServerResponse(response)
1151
1718
 
 
1719
    @needs_read_lock
1152
1720
    def sprout(self, to_bzrdir, revision_id=None):
1153
 
        # TODO: Option to control what format is created?
1154
 
        self._ensure_real()
1155
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1156
 
                                                             shared=False)
 
1721
        """Create a descendent repository for new development.
 
1722
 
 
1723
        Unlike clone, this does not copy the settings of the repository.
 
1724
        """
 
1725
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1157
1726
        dest_repo.fetch(self, revision_id=revision_id)
1158
1727
        return dest_repo
1159
1728
 
 
1729
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1730
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1731
            # use target default format.
 
1732
            dest_repo = a_bzrdir.create_repository()
 
1733
        else:
 
1734
            # Most control formats need the repository to be specifically
 
1735
            # created, but on some old all-in-one formats it's not needed
 
1736
            try:
 
1737
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1738
            except errors.UninitializableFormat:
 
1739
                dest_repo = a_bzrdir.open_repository()
 
1740
        return dest_repo
 
1741
 
1160
1742
    ### These methods are just thin shims to the VFS object for now.
1161
1743
 
 
1744
    @needs_read_lock
1162
1745
    def revision_tree(self, revision_id):
1163
 
        self._ensure_real()
1164
 
        return self._real_repository.revision_tree(revision_id)
 
1746
        revision_id = _mod_revision.ensure_null(revision_id)
 
1747
        if revision_id == _mod_revision.NULL_REVISION:
 
1748
            return InventoryRevisionTree(self,
 
1749
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1750
        else:
 
1751
            return list(self.revision_trees([revision_id]))[0]
1165
1752
 
1166
1753
    def get_serializer_format(self):
1167
 
        self._ensure_real()
1168
 
        return self._real_repository.get_serializer_format()
 
1754
        path = self.bzrdir._path_for_remote_call(self._client)
 
1755
        try:
 
1756
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1757
                path)
 
1758
        except errors.UnknownSmartMethod:
 
1759
            self._ensure_real()
 
1760
            return self._real_repository.get_serializer_format()
 
1761
        if response[0] != 'ok':
 
1762
            raise errors.UnexpectedSmartServerResponse(response)
 
1763
        return response[1]
1169
1764
 
1170
1765
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1171
1766
                           timezone=None, committer=None, revprops=None,
1172
 
                           revision_id=None):
 
1767
                           revision_id=None, lossy=False):
1173
1768
        # FIXME: It ought to be possible to call this without immediately
1174
1769
        # triggering _ensure_real.  For now it's the easiest thing to do.
1175
1770
        self._ensure_real()
1176
1771
        real_repo = self._real_repository
1177
1772
        builder = real_repo.get_commit_builder(branch, parents,
1178
1773
                config, timestamp=timestamp, timezone=timezone,
1179
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1774
                committer=committer, revprops=revprops,
 
1775
                revision_id=revision_id, lossy=lossy)
1180
1776
        return builder
1181
1777
 
1182
1778
    def add_fallback_repository(self, repository):
1190
1786
        # We need to accumulate additional repositories here, to pass them in
1191
1787
        # on various RPC's.
1192
1788
        #
 
1789
        # Make the check before we lock: this raises an exception.
 
1790
        self._check_fallback_repository(repository)
1193
1791
        if self.is_locked():
1194
1792
            # We will call fallback.unlock() when we transition to the unlocked
1195
1793
            # state, so always add a lock here. If a caller passes us a locked
1200
1798
        # _real_branch had its get_stacked_on_url method called), then the
1201
1799
        # repository to be added may already be in the _real_repositories list.
1202
1800
        if self._real_repository is not None:
1203
 
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1801
            fallback_locations = [repo.user_url for repo in
1204
1802
                self._real_repository._fallback_repositories]
1205
 
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1803
            if repository.user_url not in fallback_locations:
1206
1804
                self._real_repository.add_fallback_repository(repository)
1207
1805
 
 
1806
    def _check_fallback_repository(self, repository):
 
1807
        """Check that this repository can fallback to repository safely.
 
1808
 
 
1809
        Raise an error if not.
 
1810
 
 
1811
        :param repository: A repository to fallback to.
 
1812
        """
 
1813
        return _mod_repository.InterRepository._assert_same_model(
 
1814
            self, repository)
 
1815
 
1208
1816
    def add_inventory(self, revid, inv, parents):
1209
1817
        self._ensure_real()
1210
1818
        return self._real_repository.add_inventory(revid, inv, parents)
1211
1819
 
1212
1820
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1213
 
                               parents):
 
1821
            parents, basis_inv=None, propagate_caches=False):
1214
1822
        self._ensure_real()
1215
1823
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1216
 
            delta, new_revision_id, parents)
 
1824
            delta, new_revision_id, parents, basis_inv=basis_inv,
 
1825
            propagate_caches=propagate_caches)
1217
1826
 
1218
1827
    def add_revision(self, rev_id, rev, inv=None, config=None):
1219
1828
        self._ensure_real()
1222
1831
 
1223
1832
    @needs_read_lock
1224
1833
    def get_inventory(self, revision_id):
 
1834
        return list(self.iter_inventories([revision_id]))[0]
 
1835
 
 
1836
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1837
        if ordering is None:
 
1838
            ordering = 'unordered'
 
1839
        path = self.bzrdir._path_for_remote_call(self._client)
 
1840
        body = "\n".join(revision_ids)
 
1841
        response_tuple, response_handler = (
 
1842
            self._call_with_body_bytes_expecting_body(
 
1843
                "VersionedFileRepository.get_inventories",
 
1844
                (path, ordering), body))
 
1845
        if response_tuple[0] != "ok":
 
1846
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1847
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1848
        byte_stream = response_handler.read_streamed_body()
 
1849
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1850
        if decoded is None:
 
1851
            # no results whatsoever
 
1852
            return
 
1853
        src_format, stream = decoded
 
1854
        if src_format.network_name() != self._format.network_name():
 
1855
            raise AssertionError(
 
1856
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1857
                src_format.network_name(), self._format.network_name()))
 
1858
        # ignore the src format, it's not really relevant
 
1859
        prev_inv = Inventory(root_id=None,
 
1860
            revision_id=_mod_revision.NULL_REVISION)
 
1861
        # there should be just one substream, with inventory deltas
 
1862
        substream_kind, substream = stream.next()
 
1863
        if substream_kind != "inventory-deltas":
 
1864
            raise AssertionError(
 
1865
                 "Unexpected stream %r received" % substream_kind)
 
1866
        for record in substream:
 
1867
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1868
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1869
            if parent_id != prev_inv.revision_id:
 
1870
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1871
                    prev_inv.revision_id))
 
1872
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1873
            yield inv, inv.revision_id
 
1874
            prev_inv = inv
 
1875
 
 
1876
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
1225
1877
        self._ensure_real()
1226
 
        return self._real_repository.get_inventory(revision_id)
 
1878
        return self._real_repository._iter_inventories(revision_ids, ordering)
1227
1879
 
1228
1880
    def iter_inventories(self, revision_ids, ordering=None):
1229
 
        self._ensure_real()
1230
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1881
        """Get many inventories by revision_ids.
 
1882
 
 
1883
        This will buffer some or all of the texts used in constructing the
 
1884
        inventories in memory, but will only parse a single inventory at a
 
1885
        time.
 
1886
 
 
1887
        :param revision_ids: The expected revision ids of the inventories.
 
1888
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1889
            specified, the order of revision_ids will be preserved (by
 
1890
            buffering if necessary).
 
1891
        :return: An iterator of inventories.
 
1892
        """
 
1893
        if ((None in revision_ids)
 
1894
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1895
            raise ValueError('cannot get null revision inventory')
 
1896
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1897
            if inv is None:
 
1898
                raise errors.NoSuchRevision(self, revid)
 
1899
            yield inv
 
1900
 
 
1901
    def _iter_inventories(self, revision_ids, ordering=None):
 
1902
        if len(revision_ids) == 0:
 
1903
            return
 
1904
        missing = set(revision_ids)
 
1905
        if ordering is None:
 
1906
            order_as_requested = True
 
1907
            invs = {}
 
1908
            order = list(revision_ids)
 
1909
            order.reverse()
 
1910
            next_revid = order.pop()
 
1911
        else:
 
1912
            order_as_requested = False
 
1913
            if ordering != 'unordered' and self._fallback_repositories:
 
1914
                raise ValueError('unsupported ordering %r' % ordering)
 
1915
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
1916
            fallback._iter_inventories for fallback in
 
1917
            self._fallback_repositories]
 
1918
        try:
 
1919
            for iter_inv in iter_inv_fns:
 
1920
                request = [revid for revid in revision_ids if revid in missing]
 
1921
                for inv, revid in iter_inv(request, ordering):
 
1922
                    if inv is None:
 
1923
                        continue
 
1924
                    missing.remove(inv.revision_id)
 
1925
                    if ordering != 'unordered':
 
1926
                        invs[revid] = inv
 
1927
                    else:
 
1928
                        yield inv, revid
 
1929
                if order_as_requested:
 
1930
                    # Yield as many results as we can while preserving order.
 
1931
                    while next_revid in invs:
 
1932
                        inv = invs.pop(next_revid)
 
1933
                        yield inv, inv.revision_id
 
1934
                        try:
 
1935
                            next_revid = order.pop()
 
1936
                        except IndexError:
 
1937
                            # We still want to fully consume the stream, just
 
1938
                            # in case it is not actually finished at this point
 
1939
                            next_revid = None
 
1940
                            break
 
1941
        except errors.UnknownSmartMethod:
 
1942
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
1943
                yield inv, revid
 
1944
            return
 
1945
        # Report missing
 
1946
        if order_as_requested:
 
1947
            if next_revid is not None:
 
1948
                yield None, next_revid
 
1949
            while order:
 
1950
                revid = order.pop()
 
1951
                yield invs.get(revid), revid
 
1952
        else:
 
1953
            while missing:
 
1954
                yield None, missing.pop()
1231
1955
 
1232
1956
    @needs_read_lock
1233
1957
    def get_revision(self, revision_id):
1234
 
        self._ensure_real()
1235
 
        return self._real_repository.get_revision(revision_id)
 
1958
        return self.get_revisions([revision_id])[0]
1236
1959
 
1237
1960
    def get_transaction(self):
1238
1961
        self._ensure_real()
1240
1963
 
1241
1964
    @needs_read_lock
1242
1965
    def clone(self, a_bzrdir, revision_id=None):
1243
 
        self._ensure_real()
1244
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1966
        dest_repo = self._create_sprouting_repo(
 
1967
            a_bzrdir, shared=self.is_shared())
 
1968
        self.copy_content_into(dest_repo, revision_id)
 
1969
        return dest_repo
1245
1970
 
1246
1971
    def make_working_trees(self):
1247
1972
        """See Repository.make_working_trees"""
1248
 
        self._ensure_real()
1249
 
        return self._real_repository.make_working_trees()
 
1973
        path = self.bzrdir._path_for_remote_call(self._client)
 
1974
        try:
 
1975
            response = self._call('Repository.make_working_trees', path)
 
1976
        except errors.UnknownSmartMethod:
 
1977
            self._ensure_real()
 
1978
            return self._real_repository.make_working_trees()
 
1979
        if response[0] not in ('yes', 'no'):
 
1980
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1981
        return response[0] == 'yes'
1250
1982
 
1251
1983
    def refresh_data(self):
1252
 
        """Re-read any data needed to to synchronise with disk.
 
1984
        """Re-read any data needed to synchronise with disk.
1253
1985
 
1254
1986
        This method is intended to be called after another repository instance
1255
1987
        (such as one used by a smart server) has inserted data into the
1256
 
        repository. It may not be called during a write group, but may be
1257
 
        called at any other time.
 
1988
        repository. On all repositories this will work outside of write groups.
 
1989
        Some repository formats (pack and newer for bzrlib native formats)
 
1990
        support refresh_data inside write groups. If called inside a write
 
1991
        group on a repository that does not support refreshing in a write group
 
1992
        IsInWriteGroupError will be raised.
1258
1993
        """
1259
 
        if self.is_in_write_group():
1260
 
            raise errors.InternalBzrError(
1261
 
                "May not refresh_data while in a write group.")
1262
1994
        if self._real_repository is not None:
1263
1995
            self._real_repository.refresh_data()
1264
1996
 
1271
2003
        included_keys = result_set.intersection(result_parents)
1272
2004
        start_keys = result_set.difference(included_keys)
1273
2005
        exclude_keys = result_parents.difference(result_set)
1274
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2006
        result = vf_search.SearchResult(start_keys, exclude_keys,
1275
2007
            len(result_set), result_set)
1276
2008
        return result
1277
2009
 
1278
2010
    @needs_read_lock
1279
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
2011
    def search_missing_revision_ids(self, other,
 
2012
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
2013
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2014
            limit=None):
1280
2015
        """Return the revision ids that other has that this does not.
1281
2016
 
1282
2017
        These are returned in topological order.
1283
2018
 
1284
2019
        revision_id: only return revision ids included by revision_id.
1285
2020
        """
1286
 
        return repository.InterRepository.get(
1287
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
2021
        if symbol_versioning.deprecated_passed(revision_id):
 
2022
            symbol_versioning.warn(
 
2023
                'search_missing_revision_ids(revision_id=...) was '
 
2024
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
2025
                DeprecationWarning, stacklevel=2)
 
2026
            if revision_ids is not None:
 
2027
                raise AssertionError(
 
2028
                    'revision_ids is mutually exclusive with revision_id')
 
2029
            if revision_id is not None:
 
2030
                revision_ids = [revision_id]
 
2031
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
2032
        return inter_repo.search_missing_revision_ids(
 
2033
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
2034
            if_present_ids=if_present_ids, limit=limit)
1288
2035
 
1289
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2036
    def fetch(self, source, revision_id=None, find_ghosts=False,
1290
2037
            fetch_spec=None):
1291
2038
        # No base implementation to use as RemoteRepository is not a subclass
1292
2039
        # of Repository; so this is a copy of Repository.fetch().
1303
2050
            # check that last_revision is in 'from' and then return a
1304
2051
            # no-operation.
1305
2052
            if (revision_id is not None and
1306
 
                not revision.is_null(revision_id)):
 
2053
                not _mod_revision.is_null(revision_id)):
1307
2054
                self.get_revision(revision_id)
1308
2055
            return 0, []
1309
2056
        # if there is no specific appropriate InterRepository, this will get
1310
2057
        # the InterRepository base class, which raises an
1311
2058
        # IncompatibleRepositories when asked to fetch.
1312
 
        inter = repository.InterRepository.get(source, self)
1313
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
2059
        inter = _mod_repository.InterRepository.get(source, self)
 
2060
        if (fetch_spec is not None and
 
2061
            not getattr(inter, "supports_fetch_spec", False)):
 
2062
            raise errors.UnsupportedOperation(
 
2063
                "fetch_spec not supported for %r" % inter)
 
2064
        return inter.fetch(revision_id=revision_id,
1314
2065
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1315
2066
 
1316
2067
    def create_bundle(self, target, base, fileobj, format=None):
1318
2069
        self._real_repository.create_bundle(target, base, fileobj, format)
1319
2070
 
1320
2071
    @needs_read_lock
 
2072
    @symbol_versioning.deprecated_method(
 
2073
        symbol_versioning.deprecated_in((2, 4, 0)))
1321
2074
    def get_ancestry(self, revision_id, topo_sorted=True):
1322
2075
        self._ensure_real()
1323
2076
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1331
2084
        return self._real_repository._get_versioned_file_checker(
1332
2085
            revisions, revision_versions_cache)
1333
2086
 
 
2087
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2088
        path = self.bzrdir._path_for_remote_call(self._client)
 
2089
        lines = []
 
2090
        identifiers = []
 
2091
        for (file_id, revid, identifier) in desired_files:
 
2092
            lines.append("%s\0%s" % (
 
2093
                osutils.safe_file_id(file_id),
 
2094
                osutils.safe_revision_id(revid)))
 
2095
            identifiers.append(identifier)
 
2096
        (response_tuple, response_handler) = (
 
2097
            self._call_with_body_bytes_expecting_body(
 
2098
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2099
        if response_tuple != ('ok', ):
 
2100
            response_handler.cancel_read_body()
 
2101
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2102
        byte_stream = response_handler.read_streamed_body()
 
2103
        def decompress_stream(start, byte_stream, unused):
 
2104
            decompressor = zlib.decompressobj()
 
2105
            yield decompressor.decompress(start)
 
2106
            while decompressor.unused_data == "":
 
2107
                try:
 
2108
                    data = byte_stream.next()
 
2109
                except StopIteration:
 
2110
                    break
 
2111
                yield decompressor.decompress(data)
 
2112
            yield decompressor.flush()
 
2113
            unused.append(decompressor.unused_data)
 
2114
        unused = ""
 
2115
        while True:
 
2116
            while not "\n" in unused:
 
2117
                unused += byte_stream.next()
 
2118
            header, rest = unused.split("\n", 1)
 
2119
            args = header.split("\0")
 
2120
            if args[0] == "absent":
 
2121
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2122
                unused = rest
 
2123
                continue
 
2124
            elif args[0] == "ok":
 
2125
                idx = int(args[1])
 
2126
            else:
 
2127
                raise errors.UnexpectedSmartServerResponse(args)
 
2128
            unused_chunks = []
 
2129
            yield (identifiers[idx],
 
2130
                decompress_stream(rest, byte_stream, unused_chunks))
 
2131
            unused = "".join(unused_chunks)
 
2132
 
1334
2133
    def iter_files_bytes(self, desired_files):
1335
2134
        """See Repository.iter_file_bytes.
1336
2135
        """
1337
 
        self._ensure_real()
1338
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2136
        try:
 
2137
            absent = {}
 
2138
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2139
                    desired_files, absent):
 
2140
                yield identifier, bytes_iterator
 
2141
            for fallback in self._fallback_repositories:
 
2142
                if not absent:
 
2143
                    break
 
2144
                desired_files = [(key[0], key[1], identifier) for
 
2145
                    (identifier, key) in absent.iteritems()]
 
2146
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2147
                    del absent[identifier]
 
2148
                    yield identifier, bytes_iterator
 
2149
            if absent:
 
2150
                # There may be more missing items, but raise an exception
 
2151
                # for just one.
 
2152
                missing_identifier = absent.keys()[0]
 
2153
                missing_key = absent[missing_identifier]
 
2154
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2155
                    file_id=missing_key[0])
 
2156
        except errors.UnknownSmartMethod:
 
2157
            self._ensure_real()
 
2158
            for (identifier, bytes_iterator) in (
 
2159
                self._real_repository.iter_files_bytes(desired_files)):
 
2160
                yield identifier, bytes_iterator
 
2161
 
 
2162
    def get_cached_parent_map(self, revision_ids):
 
2163
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2164
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1339
2165
 
1340
2166
    def get_parent_map(self, revision_ids):
1341
2167
        """See bzrlib.Graph.get_parent_map()."""
1400
2226
        if parents_map is None:
1401
2227
            # Repository is not locked, so there's no cache.
1402
2228
            parents_map = {}
1403
 
        # start_set is all the keys in the cache
1404
 
        start_set = set(parents_map)
1405
 
        # result set is all the references to keys in the cache
1406
 
        result_parents = set()
1407
 
        for parents in parents_map.itervalues():
1408
 
            result_parents.update(parents)
1409
 
        stop_keys = result_parents.difference(start_set)
1410
 
        # We don't need to send ghosts back to the server as a position to
1411
 
        # stop either.
1412
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1413
 
        key_count = len(parents_map)
1414
 
        if (NULL_REVISION in result_parents
1415
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1416
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1417
 
            # in our cache of "missing" keys we need to increment our key count
1418
 
            # by 1, because the reconsitituted SearchResult on the server will
1419
 
            # still consider NULL_REVISION to be an included key.
1420
 
            key_count += 1
1421
 
        included_keys = start_set.intersection(result_parents)
1422
 
        start_set.difference_update(included_keys)
 
2229
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2230
            (start_set, stop_keys,
 
2231
             key_count) = vf_search.search_result_from_parent_map(
 
2232
                parents_map, self._unstacked_provider.missing_keys)
 
2233
        else:
 
2234
            (start_set, stop_keys,
 
2235
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2236
                parents_map, self._unstacked_provider.missing_keys,
 
2237
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1423
2238
        recipe = ('manual', start_set, stop_keys, key_count)
1424
2239
        body = self._serialise_search_recipe(recipe)
1425
2240
        path = self.bzrdir._path_for_remote_call(self._client)
1474
2289
 
1475
2290
    @needs_read_lock
1476
2291
    def get_signature_text(self, revision_id):
1477
 
        self._ensure_real()
1478
 
        return self._real_repository.get_signature_text(revision_id)
 
2292
        path = self.bzrdir._path_for_remote_call(self._client)
 
2293
        try:
 
2294
            response_tuple, response_handler = self._call_expecting_body(
 
2295
                'Repository.get_revision_signature_text', path, revision_id)
 
2296
        except errors.UnknownSmartMethod:
 
2297
            self._ensure_real()
 
2298
            return self._real_repository.get_signature_text(revision_id)
 
2299
        except errors.NoSuchRevision, err:
 
2300
            for fallback in self._fallback_repositories:
 
2301
                try:
 
2302
                    return fallback.get_signature_text(revision_id)
 
2303
                except errors.NoSuchRevision:
 
2304
                    pass
 
2305
            raise err
 
2306
        else:
 
2307
            if response_tuple[0] != 'ok':
 
2308
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2309
            return response_handler.read_body_bytes()
1479
2310
 
1480
2311
    @needs_read_lock
1481
 
    def get_inventory_xml(self, revision_id):
1482
 
        self._ensure_real()
1483
 
        return self._real_repository.get_inventory_xml(revision_id)
1484
 
 
1485
 
    def deserialise_inventory(self, revision_id, xml):
1486
 
        self._ensure_real()
1487
 
        return self._real_repository.deserialise_inventory(revision_id, xml)
1488
 
 
 
2312
    def _get_inventory_xml(self, revision_id):
 
2313
        # This call is used by older working tree formats,
 
2314
        # which stored a serialized basis inventory.
 
2315
        self._ensure_real()
 
2316
        return self._real_repository._get_inventory_xml(revision_id)
 
2317
 
 
2318
    @needs_write_lock
1489
2319
    def reconcile(self, other=None, thorough=False):
1490
 
        self._ensure_real()
1491
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2320
        from bzrlib.reconcile import RepoReconciler
 
2321
        path = self.bzrdir._path_for_remote_call(self._client)
 
2322
        try:
 
2323
            response, handler = self._call_expecting_body(
 
2324
                'Repository.reconcile', path, self._lock_token)
 
2325
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2326
            self._ensure_real()
 
2327
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2328
        if response != ('ok', ):
 
2329
            raise errors.UnexpectedSmartServerResponse(response)
 
2330
        body = handler.read_body_bytes()
 
2331
        result = RepoReconciler(self)
 
2332
        for line in body.split('\n'):
 
2333
            if not line:
 
2334
                continue
 
2335
            key, val_text = line.split(':')
 
2336
            if key == "garbage_inventories":
 
2337
                result.garbage_inventories = int(val_text)
 
2338
            elif key == "inconsistent_parents":
 
2339
                result.inconsistent_parents = int(val_text)
 
2340
            else:
 
2341
                mutter("unknown reconcile key %r" % key)
 
2342
        return result
1492
2343
 
1493
2344
    def all_revision_ids(self):
1494
 
        self._ensure_real()
1495
 
        return self._real_repository.all_revision_ids()
 
2345
        path = self.bzrdir._path_for_remote_call(self._client)
 
2346
        try:
 
2347
            response_tuple, response_handler = self._call_expecting_body(
 
2348
                "Repository.all_revision_ids", path)
 
2349
        except errors.UnknownSmartMethod:
 
2350
            self._ensure_real()
 
2351
            return self._real_repository.all_revision_ids()
 
2352
        if response_tuple != ("ok", ):
 
2353
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2354
        revids = set(response_handler.read_body_bytes().splitlines())
 
2355
        for fallback in self._fallback_repositories:
 
2356
            revids.update(set(fallback.all_revision_ids()))
 
2357
        return list(revids)
 
2358
 
 
2359
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2360
        """Return Tree for a revision on this branch with only some files.
 
2361
 
 
2362
        :param revision_ids: a sequence of revision-ids;
 
2363
          a revision-id may not be None or 'null:'
 
2364
        :param file_ids: if not None, the result is filtered
 
2365
          so that only those file-ids, their parents and their
 
2366
          children are included.
 
2367
        """
 
2368
        inventories = self.iter_inventories(revision_ids)
 
2369
        for inv in inventories:
 
2370
            # Should we introduce a FilteredRevisionTree class rather
 
2371
            # than pre-filter the inventory here?
 
2372
            filtered_inv = inv.filter(file_ids)
 
2373
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1496
2374
 
1497
2375
    @needs_read_lock
1498
2376
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1499
 
        self._ensure_real()
1500
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1501
 
            specific_fileids=specific_fileids)
 
2377
        medium = self._client._medium
 
2378
        if medium._is_remote_before((1, 2)):
 
2379
            self._ensure_real()
 
2380
            for delta in self._real_repository.get_deltas_for_revisions(
 
2381
                    revisions, specific_fileids):
 
2382
                yield delta
 
2383
            return
 
2384
        # Get the revision-ids of interest
 
2385
        required_trees = set()
 
2386
        for revision in revisions:
 
2387
            required_trees.add(revision.revision_id)
 
2388
            required_trees.update(revision.parent_ids[:1])
 
2389
 
 
2390
        # Get the matching filtered trees. Note that it's more
 
2391
        # efficient to pass filtered trees to changes_from() rather
 
2392
        # than doing the filtering afterwards. changes_from() could
 
2393
        # arguably do the filtering itself but it's path-based, not
 
2394
        # file-id based, so filtering before or afterwards is
 
2395
        # currently easier.
 
2396
        if specific_fileids is None:
 
2397
            trees = dict((t.get_revision_id(), t) for
 
2398
                t in self.revision_trees(required_trees))
 
2399
        else:
 
2400
            trees = dict((t.get_revision_id(), t) for
 
2401
                t in self._filtered_revision_trees(required_trees,
 
2402
                specific_fileids))
 
2403
 
 
2404
        # Calculate the deltas
 
2405
        for revision in revisions:
 
2406
            if not revision.parent_ids:
 
2407
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2408
            else:
 
2409
                old_tree = trees[revision.parent_ids[0]]
 
2410
            yield trees[revision.revision_id].changes_from(old_tree)
1502
2411
 
1503
2412
    @needs_read_lock
1504
2413
    def get_revision_delta(self, revision_id, specific_fileids=None):
1505
 
        self._ensure_real()
1506
 
        return self._real_repository.get_revision_delta(revision_id,
1507
 
            specific_fileids=specific_fileids)
 
2414
        r = self.get_revision(revision_id)
 
2415
        return list(self.get_deltas_for_revisions([r],
 
2416
            specific_fileids=specific_fileids))[0]
1508
2417
 
1509
2418
    @needs_read_lock
1510
2419
    def revision_trees(self, revision_ids):
1511
 
        self._ensure_real()
1512
 
        return self._real_repository.revision_trees(revision_ids)
 
2420
        inventories = self.iter_inventories(revision_ids)
 
2421
        for inv in inventories:
 
2422
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1513
2423
 
1514
2424
    @needs_read_lock
1515
2425
    def get_revision_reconcile(self, revision_id):
1523
2433
            callback_refs=callback_refs, check_repo=check_repo)
1524
2434
 
1525
2435
    def copy_content_into(self, destination, revision_id=None):
1526
 
        self._ensure_real()
1527
 
        return self._real_repository.copy_content_into(
1528
 
            destination, revision_id=revision_id)
 
2436
        """Make a complete copy of the content in self into destination.
 
2437
 
 
2438
        This is a destructive operation! Do not use it on existing
 
2439
        repositories.
 
2440
        """
 
2441
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2442
        return interrepo.copy_content(revision_id)
1529
2443
 
1530
2444
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1531
2445
        # get a tarball of the remote repository, and copy from that into the
1532
2446
        # destination
1533
 
        from bzrlib import osutils
1534
2447
        import tarfile
1535
2448
        # TODO: Maybe a progress bar while streaming the tarball?
1536
 
        note("Copying repository content as tarball...")
 
2449
        note(gettext("Copying repository content as tarball..."))
1537
2450
        tar_file = self._get_tarball('bz2')
1538
2451
        if tar_file is None:
1539
2452
            return None
1544
2457
            tmpdir = osutils.mkdtemp()
1545
2458
            try:
1546
2459
                _extract_tar(tar, tmpdir)
1547
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2460
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1548
2461
                tmp_repo = tmp_bzrdir.open_repository()
1549
2462
                tmp_repo.copy_content_into(destination, revision_id)
1550
2463
            finally:
1566
2479
        return self._real_repository.inventories
1567
2480
 
1568
2481
    @needs_write_lock
1569
 
    def pack(self, hint=None):
 
2482
    def pack(self, hint=None, clean_obsolete_packs=False):
1570
2483
        """Compress the data within the repository.
1571
 
 
1572
 
        This is not currently implemented within the smart server.
1573
2484
        """
1574
 
        self._ensure_real()
1575
 
        return self._real_repository.pack(hint=hint)
 
2485
        if hint is None:
 
2486
            body = ""
 
2487
        else:
 
2488
            body = "".join([l+"\n" for l in hint])
 
2489
        path = self.bzrdir._path_for_remote_call(self._client)
 
2490
        try:
 
2491
            response, handler = self._call_with_body_bytes_expecting_body(
 
2492
                'Repository.pack', (path, self._lock_token,
 
2493
                    str(clean_obsolete_packs)), body)
 
2494
        except errors.UnknownSmartMethod:
 
2495
            self._ensure_real()
 
2496
            return self._real_repository.pack(hint=hint,
 
2497
                clean_obsolete_packs=clean_obsolete_packs)
 
2498
        handler.cancel_read_body()
 
2499
        if response != ('ok', ):
 
2500
            raise errors.UnexpectedSmartServerResponse(response)
1576
2501
 
1577
2502
    @property
1578
2503
    def revisions(self):
1579
2504
        """Decorate the real repository for now.
1580
2505
 
1581
 
        In the short term this should become a real object to intercept graph
1582
 
        lookups.
1583
 
 
1584
2506
        In the long term a full blown network facility is needed.
1585
2507
        """
1586
2508
        self._ensure_real()
1614
2536
 
1615
2537
    @needs_write_lock
1616
2538
    def sign_revision(self, revision_id, gpg_strategy):
1617
 
        self._ensure_real()
1618
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2539
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2540
        plaintext = testament.as_short_text()
 
2541
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1619
2542
 
1620
2543
    @property
1621
2544
    def texts(self):
1627
2550
        self._ensure_real()
1628
2551
        return self._real_repository.texts
1629
2552
 
 
2553
    def _iter_revisions_rpc(self, revision_ids):
 
2554
        body = "\n".join(revision_ids)
 
2555
        path = self.bzrdir._path_for_remote_call(self._client)
 
2556
        response_tuple, response_handler = (
 
2557
            self._call_with_body_bytes_expecting_body(
 
2558
            "Repository.iter_revisions", (path, ), body))
 
2559
        if response_tuple[0] != "ok":
 
2560
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2561
        serializer_format = response_tuple[1]
 
2562
        serializer = serializer_format_registry.get(serializer_format)
 
2563
        byte_stream = response_handler.read_streamed_body()
 
2564
        decompressor = zlib.decompressobj()
 
2565
        chunks = []
 
2566
        for bytes in byte_stream:
 
2567
            chunks.append(decompressor.decompress(bytes))
 
2568
            if decompressor.unused_data != "":
 
2569
                chunks.append(decompressor.flush())
 
2570
                yield serializer.read_revision_from_string("".join(chunks))
 
2571
                unused = decompressor.unused_data
 
2572
                decompressor = zlib.decompressobj()
 
2573
                chunks = [decompressor.decompress(unused)]
 
2574
        chunks.append(decompressor.flush())
 
2575
        text = "".join(chunks)
 
2576
        if text != "":
 
2577
            yield serializer.read_revision_from_string("".join(chunks))
 
2578
 
1630
2579
    @needs_read_lock
1631
2580
    def get_revisions(self, revision_ids):
1632
 
        self._ensure_real()
1633
 
        return self._real_repository.get_revisions(revision_ids)
 
2581
        if revision_ids is None:
 
2582
            revision_ids = self.all_revision_ids()
 
2583
        else:
 
2584
            for rev_id in revision_ids:
 
2585
                if not rev_id or not isinstance(rev_id, basestring):
 
2586
                    raise errors.InvalidRevisionId(
 
2587
                        revision_id=rev_id, branch=self)
 
2588
        try:
 
2589
            missing = set(revision_ids)
 
2590
            revs = {}
 
2591
            for rev in self._iter_revisions_rpc(revision_ids):
 
2592
                missing.remove(rev.revision_id)
 
2593
                revs[rev.revision_id] = rev
 
2594
        except errors.UnknownSmartMethod:
 
2595
            self._ensure_real()
 
2596
            return self._real_repository.get_revisions(revision_ids)
 
2597
        for fallback in self._fallback_repositories:
 
2598
            if not missing:
 
2599
                break
 
2600
            for revid in list(missing):
 
2601
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2602
                # public method on Repository that could be used to query
 
2603
                # for revision objects *without* failing completely if one
 
2604
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2605
                # but unfortunately that's private and not provided by
 
2606
                # all repository implementations.
 
2607
                try:
 
2608
                    revs[revid] = fallback.get_revision(revid)
 
2609
                except errors.NoSuchRevision:
 
2610
                    pass
 
2611
                else:
 
2612
                    missing.remove(revid)
 
2613
        if missing:
 
2614
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2615
        return [revs[revid] for revid in revision_ids]
1634
2616
 
1635
2617
    def supports_rich_root(self):
1636
2618
        return self._format.rich_root_data
1637
2619
 
 
2620
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1638
2621
    def iter_reverse_revision_history(self, revision_id):
1639
2622
        self._ensure_real()
1640
2623
        return self._real_repository.iter_reverse_revision_history(revision_id)
1643
2626
    def _serializer(self):
1644
2627
        return self._format._serializer
1645
2628
 
 
2629
    @needs_write_lock
1646
2630
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1647
 
        self._ensure_real()
1648
 
        return self._real_repository.store_revision_signature(
1649
 
            gpg_strategy, plaintext, revision_id)
 
2631
        signature = gpg_strategy.sign(plaintext)
 
2632
        self.add_signature_text(revision_id, signature)
1650
2633
 
1651
2634
    def add_signature_text(self, revision_id, signature):
1652
 
        self._ensure_real()
1653
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2635
        if self._real_repository:
 
2636
            # If there is a real repository the write group will
 
2637
            # be in the real repository as well, so use that:
 
2638
            self._ensure_real()
 
2639
            return self._real_repository.add_signature_text(
 
2640
                revision_id, signature)
 
2641
        path = self.bzrdir._path_for_remote_call(self._client)
 
2642
        response, handler = self._call_with_body_bytes_expecting_body(
 
2643
            'Repository.add_signature_text', (path, self._lock_token,
 
2644
                revision_id) + tuple(self._write_group_tokens), signature)
 
2645
        handler.cancel_read_body()
 
2646
        self.refresh_data()
 
2647
        if response[0] != 'ok':
 
2648
            raise errors.UnexpectedSmartServerResponse(response)
 
2649
        self._write_group_tokens = response[1:]
1654
2650
 
1655
2651
    def has_signature_for_revision_id(self, revision_id):
1656
 
        self._ensure_real()
1657
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2652
        path = self.bzrdir._path_for_remote_call(self._client)
 
2653
        try:
 
2654
            response = self._call('Repository.has_signature_for_revision_id',
 
2655
                path, revision_id)
 
2656
        except errors.UnknownSmartMethod:
 
2657
            self._ensure_real()
 
2658
            return self._real_repository.has_signature_for_revision_id(
 
2659
                revision_id)
 
2660
        if response[0] not in ('yes', 'no'):
 
2661
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2662
        if response[0] == 'yes':
 
2663
            return True
 
2664
        for fallback in self._fallback_repositories:
 
2665
            if fallback.has_signature_for_revision_id(revision_id):
 
2666
                return True
 
2667
        return False
 
2668
 
 
2669
    @needs_read_lock
 
2670
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2671
        if not self.has_signature_for_revision_id(revision_id):
 
2672
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2673
        signature = self.get_signature_text(revision_id)
 
2674
 
 
2675
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2676
        plaintext = testament.as_short_text()
 
2677
 
 
2678
        return gpg_strategy.verify(signature, plaintext)
1658
2679
 
1659
2680
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1660
2681
        self._ensure_real()
1661
2682
        return self._real_repository.item_keys_introduced_by(revision_ids,
1662
2683
            _files_pb=_files_pb)
1663
2684
 
1664
 
    def revision_graph_can_have_wrong_parents(self):
1665
 
        # The answer depends on the remote repo format.
1666
 
        self._ensure_real()
1667
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1668
 
 
1669
2685
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1670
2686
        self._ensure_real()
1671
2687
        return self._real_repository._find_inconsistent_revision_parents(
1679
2695
        providers = [self._unstacked_provider]
1680
2696
        if other is not None:
1681
2697
            providers.insert(0, other)
1682
 
        providers.extend(r._make_parents_provider() for r in
1683
 
                         self._fallback_repositories)
1684
 
        return graph.StackedParentsProvider(providers)
 
2698
        return graph.StackedParentsProvider(_LazyListJoin(
 
2699
            providers, self._fallback_repositories))
1685
2700
 
1686
2701
    def _serialise_search_recipe(self, recipe):
1687
2702
        """Serialise a graph search recipe.
1695
2710
        return '\n'.join((start_keys, stop_keys, count))
1696
2711
 
1697
2712
    def _serialise_search_result(self, search_result):
1698
 
        if isinstance(search_result, graph.PendingAncestryResult):
1699
 
            parts = ['ancestry-of']
1700
 
            parts.extend(search_result.heads)
1701
 
        else:
1702
 
            recipe = search_result.get_recipe()
1703
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2713
        parts = search_result.get_network_struct()
1704
2714
        return '\n'.join(parts)
1705
2715
 
1706
2716
    def autopack(self):
1716
2726
            raise errors.UnexpectedSmartServerResponse(response)
1717
2727
 
1718
2728
 
1719
 
class RemoteStreamSink(repository.StreamSink):
 
2729
class RemoteStreamSink(vf_repository.StreamSink):
1720
2730
 
1721
2731
    def _insert_real(self, stream, src_format, resume_tokens):
1722
2732
        self.target_repo._ensure_real()
1823
2833
        self._last_substream and self._last_stream so that the stream can be
1824
2834
        resumed by _resume_stream_with_vfs.
1825
2835
        """
1826
 
                    
 
2836
 
1827
2837
        stream_iter = iter(stream)
1828
2838
        for substream_kind, substream in stream_iter:
1829
2839
            if substream_kind == 'inventory-deltas':
1832
2842
                return
1833
2843
            else:
1834
2844
                yield substream_kind, substream
1835
 
            
1836
 
 
1837
 
class RemoteStreamSource(repository.StreamSource):
 
2845
 
 
2846
 
 
2847
class RemoteStreamSource(vf_repository.StreamSource):
1838
2848
    """Stream data from a remote server."""
1839
2849
 
1840
2850
    def get_stream(self, search):
1861
2871
 
1862
2872
    def _real_stream(self, repo, search):
1863
2873
        """Get a stream for search from repo.
1864
 
        
1865
 
        This never called RemoteStreamSource.get_stream, and is a heler
1866
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2874
 
 
2875
        This never called RemoteStreamSource.get_stream, and is a helper
 
2876
        for RemoteStreamSource._get_stream to allow getting a stream
1867
2877
        reliably whether fallback back because of old servers or trying
1868
2878
        to stream from a non-RemoteRepository (which the stacked support
1869
2879
        code will do).
1900
2910
        candidate_verbs = [
1901
2911
            ('Repository.get_stream_1.19', (1, 19)),
1902
2912
            ('Repository.get_stream', (1, 13))]
 
2913
 
1903
2914
        found_verb = False
1904
2915
        for verb, version in candidate_verbs:
1905
2916
            if medium._is_remote_before(version):
1909
2920
                    verb, args, search_bytes)
1910
2921
            except errors.UnknownSmartMethod:
1911
2922
                medium._remember_remote_is_before(version)
 
2923
            except errors.UnknownErrorFromSmartServer, e:
 
2924
                if isinstance(search, vf_search.EverythingResult):
 
2925
                    error_verb = e.error_from_smart_server.error_verb
 
2926
                    if error_verb == 'BadSearch':
 
2927
                        # Pre-2.4 servers don't support this sort of search.
 
2928
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2929
                        # good idea in general?  It might provide a little bit
 
2930
                        # of protection against client-side bugs.
 
2931
                        medium._remember_remote_is_before((2, 4))
 
2932
                        break
 
2933
                raise
1912
2934
            else:
1913
2935
                response_tuple, response_handler = response
1914
2936
                found_verb = True
1918
2940
        if response_tuple[0] != 'ok':
1919
2941
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1920
2942
        byte_stream = response_handler.read_streamed_body()
1921
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2943
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2944
            self._record_counter)
1922
2945
        if src_format.network_name() != repo._format.network_name():
1923
2946
            raise AssertionError(
1924
2947
                "Mismatched RemoteRepository and stream src %r, %r" % (
1996
3019
 
1997
3020
    def _ensure_real(self):
1998
3021
        if self._custom_format is None:
1999
 
            self._custom_format = branch.network_format_registry.get(
2000
 
                self._network_name)
 
3022
            try:
 
3023
                self._custom_format = branch.network_format_registry.get(
 
3024
                    self._network_name)
 
3025
            except KeyError:
 
3026
                raise errors.UnknownFormatError(kind='branch',
 
3027
                    format=self._network_name)
2001
3028
 
2002
3029
    def get_format_description(self):
2003
3030
        self._ensure_real()
2006
3033
    def network_name(self):
2007
3034
        return self._network_name
2008
3035
 
2009
 
    def open(self, a_bzrdir, ignore_fallbacks=False):
2010
 
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
3036
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
 
3037
        return a_bzrdir.open_branch(name=name, 
 
3038
            ignore_fallbacks=ignore_fallbacks)
2011
3039
 
2012
 
    def _vfs_initialize(self, a_bzrdir):
 
3040
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2013
3041
        # Initialisation when using a local bzrdir object, or a non-vfs init
2014
3042
        # method is not available on the server.
2015
3043
        # self._custom_format is always set - the start of initialize ensures
2016
3044
        # that.
2017
3045
        if isinstance(a_bzrdir, RemoteBzrDir):
2018
3046
            a_bzrdir._ensure_real()
2019
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
 
3047
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
 
3048
                name, append_revisions_only=append_revisions_only)
2020
3049
        else:
2021
3050
            # We assume the bzrdir is parameterised; it may not be.
2022
 
            result = self._custom_format.initialize(a_bzrdir)
 
3051
            result = self._custom_format.initialize(a_bzrdir, name,
 
3052
                append_revisions_only=append_revisions_only)
2023
3053
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2024
3054
            not isinstance(result, RemoteBranch)):
2025
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
 
3055
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
3056
                                  name=name)
2026
3057
        return result
2027
3058
 
2028
 
    def initialize(self, a_bzrdir):
 
3059
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3060
                   append_revisions_only=None):
2029
3061
        # 1) get the network name to use.
2030
3062
        if self._custom_format:
2031
3063
            network_name = self._custom_format.network_name()
2032
3064
        else:
2033
3065
            # Select the current bzrlib default and ask for that.
2034
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3066
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2035
3067
            reference_format = reference_bzrdir_format.get_branch_format()
2036
3068
            self._custom_format = reference_format
2037
3069
            network_name = reference_format.network_name()
2038
3070
        # Being asked to create on a non RemoteBzrDir:
2039
3071
        if not isinstance(a_bzrdir, RemoteBzrDir):
2040
 
            return self._vfs_initialize(a_bzrdir)
 
3072
            return self._vfs_initialize(a_bzrdir, name=name,
 
3073
                append_revisions_only=append_revisions_only)
2041
3074
        medium = a_bzrdir._client._medium
2042
3075
        if medium._is_remote_before((1, 13)):
2043
 
            return self._vfs_initialize(a_bzrdir)
 
3076
            return self._vfs_initialize(a_bzrdir, name=name,
 
3077
                append_revisions_only=append_revisions_only)
2044
3078
        # Creating on a remote bzr dir.
2045
3079
        # 2) try direct creation via RPC
2046
3080
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
3081
        if name is not None:
 
3082
            # XXX JRV20100304: Support creating colocated branches
 
3083
            raise errors.NoColocatedBranchSupport(self)
2047
3084
        verb = 'BzrDir.create_branch'
2048
3085
        try:
2049
3086
            response = a_bzrdir._call(verb, path, network_name)
2050
3087
        except errors.UnknownSmartMethod:
2051
3088
            # Fallback - use vfs methods
2052
3089
            medium._remember_remote_is_before((1, 13))
2053
 
            return self._vfs_initialize(a_bzrdir)
 
3090
            return self._vfs_initialize(a_bzrdir, name=name,
 
3091
                    append_revisions_only=append_revisions_only)
2054
3092
        if response[0] != 'ok':
2055
3093
            raise errors.UnexpectedSmartServerResponse(response)
2056
3094
        # Turn the response into a RemoteRepository object.
2057
3095
        format = RemoteBranchFormat(network_name=response[1])
2058
3096
        repo_format = response_tuple_to_repo_format(response[3:])
2059
 
        if response[2] == '':
2060
 
            repo_bzrdir = a_bzrdir
 
3097
        repo_path = response[2]
 
3098
        if repository is not None:
 
3099
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
3100
            url_diff = urlutils.relative_url(repository.user_url,
 
3101
                    remote_repo_url)
 
3102
            if url_diff != '.':
 
3103
                raise AssertionError(
 
3104
                    'repository.user_url %r does not match URL from server '
 
3105
                    'response (%r + %r)'
 
3106
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
3107
            remote_repo = repository
2061
3108
        else:
2062
 
            repo_bzrdir = RemoteBzrDir(
2063
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2064
 
                a_bzrdir._client)
2065
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
3109
            if repo_path == '':
 
3110
                repo_bzrdir = a_bzrdir
 
3111
            else:
 
3112
                repo_bzrdir = RemoteBzrDir(
 
3113
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
3114
                    a_bzrdir._client)
 
3115
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2066
3116
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2067
 
            format=format, setup_stacking=False)
 
3117
            format=format, setup_stacking=False, name=name)
 
3118
        if append_revisions_only:
 
3119
            remote_branch.set_append_revisions_only(append_revisions_only)
2068
3120
        # XXX: We know this is a new branch, so it must have revno 0, revid
2069
3121
        # NULL_REVISION. Creating the branch locked would make this be unable
2070
3122
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2089
3141
        self._ensure_real()
2090
3142
        return self._custom_format.supports_set_append_revisions_only()
2091
3143
 
 
3144
    def _use_default_local_heads_to_fetch(self):
 
3145
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3146
        # implementation is not overridden vs the base class, we can use the
 
3147
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3148
        # usually cheaper in terms of net round trips, as the last-revision and
 
3149
        # tags info fetched is cached and would be fetched anyway.
 
3150
        self._ensure_real()
 
3151
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3152
            branch_class = self._custom_format._branch_class()
 
3153
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3154
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3155
                return True
 
3156
        return False
 
3157
 
 
3158
 
 
3159
class RemoteBranchStore(config.IniFileStore):
 
3160
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3161
 
 
3162
    Note that this is specific to bzr-based formats.
 
3163
    """
 
3164
 
 
3165
    def __init__(self, branch):
 
3166
        super(RemoteBranchStore, self).__init__()
 
3167
        self.branch = branch
 
3168
        self.id = "branch"
 
3169
        self._real_store = None
 
3170
 
 
3171
    def lock_write(self, token=None):
 
3172
        return self.branch.lock_write(token)
 
3173
 
 
3174
    def unlock(self):
 
3175
        return self.branch.unlock()
 
3176
 
 
3177
    @needs_write_lock
 
3178
    def save(self):
 
3179
        # We need to be able to override the undecorated implementation
 
3180
        self.save_without_locking()
 
3181
 
 
3182
    def save_without_locking(self):
 
3183
        super(RemoteBranchStore, self).save()
 
3184
 
 
3185
    def external_url(self):
 
3186
        return self.branch.user_url
 
3187
 
 
3188
    def _load_content(self):
 
3189
        path = self.branch._remote_path()
 
3190
        try:
 
3191
            response, handler = self.branch._call_expecting_body(
 
3192
                'Branch.get_config_file', path)
 
3193
        except errors.UnknownSmartMethod:
 
3194
            self._ensure_real()
 
3195
            return self._real_store._load_content()
 
3196
        if len(response) and response[0] != 'ok':
 
3197
            raise errors.UnexpectedSmartServerResponse(response)
 
3198
        return handler.read_body_bytes()
 
3199
 
 
3200
    def _save_content(self, content):
 
3201
        path = self.branch._remote_path()
 
3202
        try:
 
3203
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3204
                'Branch.put_config_file', (path,
 
3205
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3206
                content)
 
3207
        except errors.UnknownSmartMethod:
 
3208
            self._ensure_real()
 
3209
            return self._real_store._save_content(content)
 
3210
        handler.cancel_read_body()
 
3211
        if response != ('ok', ):
 
3212
            raise errors.UnexpectedSmartServerResponse(response)
 
3213
 
 
3214
    def _ensure_real(self):
 
3215
        self.branch._ensure_real()
 
3216
        if self._real_store is None:
 
3217
            self._real_store = config.BranchStore(self.branch)
 
3218
 
2092
3219
 
2093
3220
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2094
3221
    """Branch stored on a server accessed by HPSS RPC.
2097
3224
    """
2098
3225
 
2099
3226
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2100
 
        _client=None, format=None, setup_stacking=True):
 
3227
        _client=None, format=None, setup_stacking=True, name=None,
 
3228
        possible_transports=None):
2101
3229
        """Create a RemoteBranch instance.
2102
3230
 
2103
3231
        :param real_branch: An optional local implementation of the branch
2109
3237
        :param setup_stacking: If True make an RPC call to determine the
2110
3238
            stacked (or not) status of the branch. If False assume the branch
2111
3239
            is not stacked.
 
3240
        :param name: Colocated branch name
2112
3241
        """
2113
3242
        # We intentionally don't call the parent class's __init__, because it
2114
3243
        # will try to assign to self.tags, which is a property in this subclass.
2133
3262
            self._real_branch = None
2134
3263
        # Fill out expected attributes of branch for bzrlib API users.
2135
3264
        self._clear_cached_state()
2136
 
        self.base = self.bzrdir.root_transport.base
 
3265
        # TODO: deprecate self.base in favor of user_url
 
3266
        self.base = self.bzrdir.user_url
 
3267
        self._name = name
2137
3268
        self._control_files = None
2138
3269
        self._lock_mode = None
2139
3270
        self._lock_token = None
2165
3296
            hook(self)
2166
3297
        self._is_stacked = False
2167
3298
        if setup_stacking:
2168
 
            self._setup_stacking()
 
3299
            self._setup_stacking(possible_transports)
2169
3300
 
2170
 
    def _setup_stacking(self):
 
3301
    def _setup_stacking(self, possible_transports):
2171
3302
        # configure stacking into the remote repository, by reading it from
2172
3303
        # the vfs branch.
2173
3304
        try:
2176
3307
            errors.UnstackableRepositoryFormat), e:
2177
3308
            return
2178
3309
        self._is_stacked = True
2179
 
        self._activate_fallback_location(fallback_url)
 
3310
        if possible_transports is None:
 
3311
            possible_transports = []
 
3312
        else:
 
3313
            possible_transports = list(possible_transports)
 
3314
        possible_transports.append(self.bzrdir.root_transport)
 
3315
        self._activate_fallback_location(fallback_url,
 
3316
            possible_transports=possible_transports)
2180
3317
 
2181
3318
    def _get_config(self):
2182
3319
        return RemoteBranchConfig(self)
2183
3320
 
 
3321
    def _get_config_store(self):
 
3322
        return RemoteBranchStore(self)
 
3323
 
2184
3324
    def _get_real_transport(self):
2185
3325
        # if we try vfs access, return the real branch's vfs transport
2186
3326
        self._ensure_real()
2204
3344
                    'to use vfs implementation')
2205
3345
            self.bzrdir._ensure_real()
2206
3346
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2207
 
                ignore_fallbacks=self._real_ignore_fallbacks)
 
3347
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2208
3348
            if self.repository._real_repository is None:
2209
3349
                # Give the remote repository the matching real repo.
2210
3350
                real_repo = self._real_branch.repository
2249
3389
                self.bzrdir, self._client)
2250
3390
        return self._control_files
2251
3391
 
2252
 
    def _get_checkout_format(self):
2253
 
        self._ensure_real()
2254
 
        return self._real_branch._get_checkout_format()
2255
 
 
2256
3392
    def get_physical_lock_status(self):
2257
3393
        """See Branch.get_physical_lock_status()."""
2258
 
        # should be an API call to the server, as branches must be lockable.
2259
 
        self._ensure_real()
2260
 
        return self._real_branch.get_physical_lock_status()
 
3394
        try:
 
3395
            response = self._client.call('Branch.get_physical_lock_status',
 
3396
                self._remote_path())
 
3397
        except errors.UnknownSmartMethod:
 
3398
            self._ensure_real()
 
3399
            return self._real_branch.get_physical_lock_status()
 
3400
        if response[0] not in ('yes', 'no'):
 
3401
            raise errors.UnexpectedSmartServerResponse(response)
 
3402
        return (response[0] == 'yes')
2261
3403
 
2262
3404
    def get_stacked_on_url(self):
2263
3405
        """Get the URL this branch is stacked against.
2290
3432
            self._is_stacked = False
2291
3433
        else:
2292
3434
            self._is_stacked = True
2293
 
        
 
3435
 
2294
3436
    def _vfs_get_tags_bytes(self):
2295
3437
        self._ensure_real()
2296
3438
        return self._real_branch._get_tags_bytes()
2297
3439
 
 
3440
    @needs_read_lock
2298
3441
    def _get_tags_bytes(self):
 
3442
        if self._tags_bytes is None:
 
3443
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3444
        return self._tags_bytes
 
3445
 
 
3446
    def _get_tags_bytes_via_hpss(self):
2299
3447
        medium = self._client._medium
2300
3448
        if medium._is_remote_before((1, 13)):
2301
3449
            return self._vfs_get_tags_bytes()
2311
3459
        return self._real_branch._set_tags_bytes(bytes)
2312
3460
 
2313
3461
    def _set_tags_bytes(self, bytes):
 
3462
        if self.is_locked():
 
3463
            self._tags_bytes = bytes
2314
3464
        medium = self._client._medium
2315
3465
        if medium._is_remote_before((1, 18)):
2316
3466
            self._vfs_set_tags_bytes(bytes)
2325
3475
            self._vfs_set_tags_bytes(bytes)
2326
3476
 
2327
3477
    def lock_read(self):
 
3478
        """Lock the branch for read operations.
 
3479
 
 
3480
        :return: A bzrlib.lock.LogicalLockResult.
 
3481
        """
2328
3482
        self.repository.lock_read()
2329
3483
        if not self._lock_mode:
2330
3484
            self._note_lock('r')
2334
3488
                self._real_branch.lock_read()
2335
3489
        else:
2336
3490
            self._lock_count += 1
 
3491
        return lock.LogicalLockResult(self.unlock)
2337
3492
 
2338
3493
    def _remote_lock_write(self, token):
2339
3494
        if token is None:
2340
3495
            branch_token = repo_token = ''
2341
3496
        else:
2342
3497
            branch_token = token
2343
 
            repo_token = self.repository.lock_write()
 
3498
            repo_token = self.repository.lock_write().repository_token
2344
3499
            self.repository.unlock()
2345
3500
        err_context = {'token': token}
2346
 
        response = self._call(
2347
 
            'Branch.lock_write', self._remote_path(), branch_token,
2348
 
            repo_token or '', **err_context)
 
3501
        try:
 
3502
            response = self._call(
 
3503
                'Branch.lock_write', self._remote_path(), branch_token,
 
3504
                repo_token or '', **err_context)
 
3505
        except errors.LockContention, e:
 
3506
            # The LockContention from the server doesn't have any
 
3507
            # information about the lock_url. We re-raise LockContention
 
3508
            # with valid lock_url.
 
3509
            raise errors.LockContention('(remote lock)',
 
3510
                self.repository.base.split('.bzr/')[0])
2349
3511
        if response[0] != 'ok':
2350
3512
            raise errors.UnexpectedSmartServerResponse(response)
2351
3513
        ok, branch_token, repo_token = response
2372
3534
            self._lock_mode = 'w'
2373
3535
            self._lock_count = 1
2374
3536
        elif self._lock_mode == 'r':
2375
 
            raise errors.ReadOnlyTransaction
 
3537
            raise errors.ReadOnlyError(self)
2376
3538
        else:
2377
3539
            if token is not None:
2378
3540
                # A token was given to lock_write, and we're relocking, so
2383
3545
            self._lock_count += 1
2384
3546
            # Re-lock the repository too.
2385
3547
            self.repository.lock_write(self._repo_lock_token)
2386
 
        return self._lock_token or None
 
3548
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2387
3549
 
2388
3550
    def _unlock(self, branch_token, repo_token):
2389
3551
        err_context = {'token': str((branch_token, repo_token))}
2427
3589
            self.repository.unlock()
2428
3590
 
2429
3591
    def break_lock(self):
2430
 
        self._ensure_real()
2431
 
        return self._real_branch.break_lock()
 
3592
        try:
 
3593
            response = self._call(
 
3594
                'Branch.break_lock', self._remote_path())
 
3595
        except errors.UnknownSmartMethod:
 
3596
            self._ensure_real()
 
3597
            return self._real_branch.break_lock()
 
3598
        if response != ('ok',):
 
3599
            raise errors.UnexpectedSmartServerResponse(response)
2432
3600
 
2433
3601
    def leave_lock_in_place(self):
2434
3602
        if not self._lock_token:
2458
3626
            missing_parent = parent_map[missing_parent]
2459
3627
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2460
3628
 
2461
 
    def _last_revision_info(self):
 
3629
    def _read_last_revision_info(self):
2462
3630
        response = self._call('Branch.last_revision_info', self._remote_path())
2463
3631
        if response[0] != 'ok':
2464
3632
            raise SmartProtocolError('unexpected response code %s' % (response,))
2527
3695
            raise errors.UnexpectedSmartServerResponse(response)
2528
3696
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2529
3697
 
 
3698
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2530
3699
    @needs_write_lock
2531
3700
    def set_revision_history(self, rev_history):
 
3701
        """See Branch.set_revision_history."""
 
3702
        self._set_revision_history(rev_history)
 
3703
 
 
3704
    @needs_write_lock
 
3705
    def _set_revision_history(self, rev_history):
2532
3706
        # Send just the tip revision of the history; the server will generate
2533
3707
        # the full history from that.  If the revision doesn't exist in this
2534
3708
        # branch, NoSuchRevision will be raised.
2592
3766
            _override_hook_target=self, **kwargs)
2593
3767
 
2594
3768
    @needs_read_lock
2595
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3769
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2596
3770
        self._ensure_real()
2597
3771
        return self._real_branch.push(
2598
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3772
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2599
3773
            _override_hook_source_branch=self)
2600
3774
 
2601
3775
    def is_locked(self):
2602
3776
        return self._lock_count >= 1
2603
3777
 
2604
3778
    @needs_read_lock
 
3779
    def revision_id_to_dotted_revno(self, revision_id):
 
3780
        """Given a revision id, return its dotted revno.
 
3781
 
 
3782
        :return: a tuple like (1,) or (400,1,3).
 
3783
        """
 
3784
        try:
 
3785
            response = self._call('Branch.revision_id_to_revno',
 
3786
                self._remote_path(), revision_id)
 
3787
        except errors.UnknownSmartMethod:
 
3788
            self._ensure_real()
 
3789
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3790
        if response[0] == 'ok':
 
3791
            return tuple([int(x) for x in response[1:]])
 
3792
        else:
 
3793
            raise errors.UnexpectedSmartServerResponse(response)
 
3794
 
 
3795
    @needs_read_lock
2605
3796
    def revision_id_to_revno(self, revision_id):
2606
 
        self._ensure_real()
2607
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3797
        """Given a revision id on the branch mainline, return its revno.
 
3798
 
 
3799
        :return: an integer
 
3800
        """
 
3801
        try:
 
3802
            response = self._call('Branch.revision_id_to_revno',
 
3803
                self._remote_path(), revision_id)
 
3804
        except errors.UnknownSmartMethod:
 
3805
            self._ensure_real()
 
3806
            return self._real_branch.revision_id_to_revno(revision_id)
 
3807
        if response[0] == 'ok':
 
3808
            if len(response) == 2:
 
3809
                return int(response[1])
 
3810
            raise NoSuchRevision(self, revision_id)
 
3811
        else:
 
3812
            raise errors.UnexpectedSmartServerResponse(response)
2608
3813
 
2609
3814
    @needs_write_lock
2610
3815
    def set_last_revision_info(self, revno, revision_id):
2611
3816
        # XXX: These should be returned by the set_last_revision_info verb
2612
3817
        old_revno, old_revid = self.last_revision_info()
2613
3818
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2614
 
        revision_id = ensure_null(revision_id)
 
3819
        if not revision_id or not isinstance(revision_id, basestring):
 
3820
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2615
3821
        try:
2616
3822
            response = self._call('Branch.set_last_revision_info',
2617
3823
                self._remote_path(), self._lock_token, self._repo_lock_token,
2646
3852
            except errors.UnknownSmartMethod:
2647
3853
                medium._remember_remote_is_before((1, 6))
2648
3854
        self._clear_cached_state_of_remote_branch_only()
2649
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3855
        self._set_revision_history(self._lefthand_history(revision_id,
2650
3856
            last_rev=last_rev,other_branch=other_branch))
2651
3857
 
2652
3858
    def set_push_location(self, location):
2653
3859
        self._ensure_real()
2654
3860
        return self._real_branch.set_push_location(location)
2655
3861
 
 
3862
    def heads_to_fetch(self):
 
3863
        if self._format._use_default_local_heads_to_fetch():
 
3864
            # We recognise this format, and its heads-to-fetch implementation
 
3865
            # is the default one (tip + tags).  In this case it's cheaper to
 
3866
            # just use the default implementation rather than a special RPC as
 
3867
            # the tip and tags data is cached.
 
3868
            return branch.Branch.heads_to_fetch(self)
 
3869
        medium = self._client._medium
 
3870
        if medium._is_remote_before((2, 4)):
 
3871
            return self._vfs_heads_to_fetch()
 
3872
        try:
 
3873
            return self._rpc_heads_to_fetch()
 
3874
        except errors.UnknownSmartMethod:
 
3875
            medium._remember_remote_is_before((2, 4))
 
3876
            return self._vfs_heads_to_fetch()
 
3877
 
 
3878
    def _rpc_heads_to_fetch(self):
 
3879
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3880
        if len(response) != 2:
 
3881
            raise errors.UnexpectedSmartServerResponse(response)
 
3882
        must_fetch, if_present_fetch = response
 
3883
        return set(must_fetch), set(if_present_fetch)
 
3884
 
 
3885
    def _vfs_heads_to_fetch(self):
 
3886
        self._ensure_real()
 
3887
        return self._real_branch.heads_to_fetch()
 
3888
 
2656
3889
 
2657
3890
class RemoteConfig(object):
2658
3891
    """A Config that reads and writes from smart verbs.
2672
3905
        """
2673
3906
        try:
2674
3907
            configobj = self._get_configobj()
 
3908
            section_obj = None
2675
3909
            if section is None:
2676
3910
                section_obj = configobj
2677
3911
            else:
2678
3912
                try:
2679
3913
                    section_obj = configobj[section]
2680
3914
                except KeyError:
2681
 
                    return default
2682
 
            return section_obj.get(name, default)
 
3915
                    pass
 
3916
            if section_obj is None:
 
3917
                value = default
 
3918
            else:
 
3919
                value = section_obj.get(name, default)
2683
3920
        except errors.UnknownSmartMethod:
2684
 
            return self._vfs_get_option(name, section, default)
 
3921
            value = self._vfs_get_option(name, section, default)
 
3922
        for hook in config.OldConfigHooks['get']:
 
3923
            hook(self, name, value)
 
3924
        return value
2685
3925
 
2686
3926
    def _response_to_configobj(self, response):
2687
3927
        if len(response[0]) and response[0][0] != 'ok':
2688
3928
            raise errors.UnexpectedSmartServerResponse(response)
2689
3929
        lines = response[1].read_body_bytes().splitlines()
2690
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3930
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3931
        for hook in config.OldConfigHooks['load']:
 
3932
            hook(self)
 
3933
        return conf
2691
3934
 
2692
3935
 
2693
3936
class RemoteBranchConfig(RemoteConfig):
2712
3955
        medium = self._branch._client._medium
2713
3956
        if medium._is_remote_before((1, 14)):
2714
3957
            return self._vfs_set_option(value, name, section)
 
3958
        if isinstance(value, dict):
 
3959
            if medium._is_remote_before((2, 2)):
 
3960
                return self._vfs_set_option(value, name, section)
 
3961
            return self._set_config_option_dict(value, name, section)
 
3962
        else:
 
3963
            return self._set_config_option(value, name, section)
 
3964
 
 
3965
    def _set_config_option(self, value, name, section):
2715
3966
        try:
2716
3967
            path = self._branch._remote_path()
2717
3968
            response = self._branch._client.call('Branch.set_config_option',
2718
3969
                path, self._branch._lock_token, self._branch._repo_lock_token,
2719
3970
                value.encode('utf8'), name, section or '')
2720
3971
        except errors.UnknownSmartMethod:
 
3972
            medium = self._branch._client._medium
2721
3973
            medium._remember_remote_is_before((1, 14))
2722
3974
            return self._vfs_set_option(value, name, section)
2723
3975
        if response != ():
2724
3976
            raise errors.UnexpectedSmartServerResponse(response)
2725
3977
 
 
3978
    def _serialize_option_dict(self, option_dict):
 
3979
        utf8_dict = {}
 
3980
        for key, value in option_dict.items():
 
3981
            if isinstance(key, unicode):
 
3982
                key = key.encode('utf8')
 
3983
            if isinstance(value, unicode):
 
3984
                value = value.encode('utf8')
 
3985
            utf8_dict[key] = value
 
3986
        return bencode.bencode(utf8_dict)
 
3987
 
 
3988
    def _set_config_option_dict(self, value, name, section):
 
3989
        try:
 
3990
            path = self._branch._remote_path()
 
3991
            serialised_dict = self._serialize_option_dict(value)
 
3992
            response = self._branch._client.call(
 
3993
                'Branch.set_config_option_dict',
 
3994
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3995
                serialised_dict, name, section or '')
 
3996
        except errors.UnknownSmartMethod:
 
3997
            medium = self._branch._client._medium
 
3998
            medium._remember_remote_is_before((2, 2))
 
3999
            return self._vfs_set_option(value, name, section)
 
4000
        if response != ():
 
4001
            raise errors.UnexpectedSmartServerResponse(response)
 
4002
 
2726
4003
    def _real_object(self):
2727
4004
        self._branch._ensure_real()
2728
4005
        return self._branch._real_branch
2767
4044
        return self._bzrdir._real_bzrdir
2768
4045
 
2769
4046
 
2770
 
 
2771
4047
def _extract_tar(tar, to_dir):
2772
4048
    """Extract all the contents of a tarfile object.
2773
4049
 
2777
4053
        tar.extract(tarinfo, to_dir)
2778
4054
 
2779
4055
 
 
4056
error_translators = registry.Registry()
 
4057
no_context_error_translators = registry.Registry()
 
4058
 
 
4059
 
2780
4060
def _translate_error(err, **context):
2781
4061
    """Translate an ErrorFromSmartServer into a more useful error.
2782
4062
 
2811
4091
                    'Missing key %r in context %r', key_err.args[0], context)
2812
4092
                raise err
2813
4093
 
2814
 
    if err.error_verb == 'IncompatibleRepositories':
2815
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2816
 
            err.error_args[1], err.error_args[2])
2817
 
    elif err.error_verb == 'NoSuchRevision':
2818
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2819
 
    elif err.error_verb == 'nosuchrevision':
2820
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2821
 
    elif err.error_tuple == ('nobranch',):
2822
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2823
 
    elif err.error_verb == 'norepository':
2824
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2825
 
    elif err.error_verb == 'LockContention':
2826
 
        raise errors.LockContention('(remote lock)')
2827
 
    elif err.error_verb == 'UnlockableTransport':
2828
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2829
 
    elif err.error_verb == 'LockFailed':
2830
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2831
 
    elif err.error_verb == 'TokenMismatch':
2832
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2833
 
    elif err.error_verb == 'Diverged':
2834
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2835
 
    elif err.error_verb == 'TipChangeRejected':
2836
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2837
 
    elif err.error_verb == 'UnstackableBranchFormat':
2838
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2839
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2840
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2841
 
    elif err.error_verb == 'NotStacked':
2842
 
        raise errors.NotStacked(branch=find('branch'))
2843
 
    elif err.error_verb == 'PermissionDenied':
2844
 
        path = get_path()
2845
 
        if len(err.error_args) >= 2:
2846
 
            extra = err.error_args[1]
2847
 
        else:
2848
 
            extra = None
2849
 
        raise errors.PermissionDenied(path, extra=extra)
2850
 
    elif err.error_verb == 'ReadError':
2851
 
        path = get_path()
2852
 
        raise errors.ReadError(path)
2853
 
    elif err.error_verb == 'NoSuchFile':
2854
 
        path = get_path()
2855
 
        raise errors.NoSuchFile(path)
2856
 
    elif err.error_verb == 'FileExists':
2857
 
        raise errors.FileExists(err.error_args[0])
2858
 
    elif err.error_verb == 'DirectoryNotEmpty':
2859
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2860
 
    elif err.error_verb == 'ShortReadvError':
2861
 
        args = err.error_args
2862
 
        raise errors.ShortReadvError(
2863
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2864
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4094
    try:
 
4095
        translator = error_translators.get(err.error_verb)
 
4096
    except KeyError:
 
4097
        pass
 
4098
    else:
 
4099
        raise translator(err, find, get_path)
 
4100
    try:
 
4101
        translator = no_context_error_translators.get(err.error_verb)
 
4102
    except KeyError:
 
4103
        raise errors.UnknownErrorFromSmartServer(err)
 
4104
    else:
 
4105
        raise translator(err)
 
4106
 
 
4107
 
 
4108
error_translators.register('NoSuchRevision',
 
4109
    lambda err, find, get_path: NoSuchRevision(
 
4110
        find('branch'), err.error_args[0]))
 
4111
error_translators.register('nosuchrevision',
 
4112
    lambda err, find, get_path: NoSuchRevision(
 
4113
        find('repository'), err.error_args[0]))
 
4114
 
 
4115
def _translate_nobranch_error(err, find, get_path):
 
4116
    if len(err.error_args) >= 1:
 
4117
        extra = err.error_args[0]
 
4118
    else:
 
4119
        extra = None
 
4120
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4121
        detail=extra)
 
4122
 
 
4123
error_translators.register('nobranch', _translate_nobranch_error)
 
4124
error_translators.register('norepository',
 
4125
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4126
        find('bzrdir')))
 
4127
error_translators.register('UnlockableTransport',
 
4128
    lambda err, find, get_path: errors.UnlockableTransport(
 
4129
        find('bzrdir').root_transport))
 
4130
error_translators.register('TokenMismatch',
 
4131
    lambda err, find, get_path: errors.TokenMismatch(
 
4132
        find('token'), '(remote token)'))
 
4133
error_translators.register('Diverged',
 
4134
    lambda err, find, get_path: errors.DivergedBranches(
 
4135
        find('branch'), find('other_branch')))
 
4136
error_translators.register('NotStacked',
 
4137
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4138
 
 
4139
def _translate_PermissionDenied(err, find, get_path):
 
4140
    path = get_path()
 
4141
    if len(err.error_args) >= 2:
 
4142
        extra = err.error_args[1]
 
4143
    else:
 
4144
        extra = None
 
4145
    return errors.PermissionDenied(path, extra=extra)
 
4146
 
 
4147
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4148
error_translators.register('ReadError',
 
4149
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4150
error_translators.register('NoSuchFile',
 
4151
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4152
error_translators.register('TokenLockingNotSupported',
 
4153
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4154
        find('repository')))
 
4155
error_translators.register('UnsuspendableWriteGroup',
 
4156
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4157
        repository=find('repository')))
 
4158
error_translators.register('UnresumableWriteGroup',
 
4159
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4160
        repository=find('repository'), write_groups=err.error_args[0],
 
4161
        reason=err.error_args[1]))
 
4162
no_context_error_translators.register('IncompatibleRepositories',
 
4163
    lambda err: errors.IncompatibleRepositories(
 
4164
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4165
no_context_error_translators.register('LockContention',
 
4166
    lambda err: errors.LockContention('(remote lock)'))
 
4167
no_context_error_translators.register('LockFailed',
 
4168
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4169
no_context_error_translators.register('TipChangeRejected',
 
4170
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4171
no_context_error_translators.register('UnstackableBranchFormat',
 
4172
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4173
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4174
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4175
no_context_error_translators.register('FileExists',
 
4176
    lambda err: errors.FileExists(err.error_args[0]))
 
4177
no_context_error_translators.register('DirectoryNotEmpty',
 
4178
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4179
 
 
4180
def _translate_short_readv_error(err):
 
4181
    args = err.error_args
 
4182
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4183
        int(args[3]))
 
4184
 
 
4185
no_context_error_translators.register('ShortReadvError',
 
4186
    _translate_short_readv_error)
 
4187
 
 
4188
def _translate_unicode_error(err):
2865
4189
        encoding = str(err.error_args[0]) # encoding must always be a string
2866
4190
        val = err.error_args[1]
2867
4191
        start = int(err.error_args[2])
2875
4199
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2876
4200
        elif err.error_verb == 'UnicodeEncodeError':
2877
4201
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2878
 
    elif err.error_verb == 'ReadOnlyError':
2879
 
        raise errors.TransportNotPossible('readonly transport')
2880
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4202
 
 
4203
no_context_error_translators.register('UnicodeEncodeError',
 
4204
    _translate_unicode_error)
 
4205
no_context_error_translators.register('UnicodeDecodeError',
 
4206
    _translate_unicode_error)
 
4207
no_context_error_translators.register('ReadOnlyError',
 
4208
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4209
no_context_error_translators.register('MemoryError',
 
4210
    lambda err: errors.BzrError("remote server out of memory\n"
 
4211
        "Retry non-remotely, or contact the server admin for details."))
 
4212
no_context_error_translators.register('RevisionNotPresent',
 
4213
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4214
 
 
4215
no_context_error_translators.register('BzrCheckError',
 
4216
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4217