/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/remote.py

  • Committer: Martin
  • Date: 2017-06-11 01:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 6685.
  • Revision ID: gzlist@googlemail.com-20170611011229-somdjbalby8m7vlw
Make _chunks_to_lines pass for Python 3

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012 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
 
from bzrlib import (
 
22
from . import (
20
23
    bencode,
21
24
    branch,
22
 
    bzrdir,
23
 
    config,
 
25
    bzrbranch,
 
26
    bzrdir as _mod_bzrdir,
 
27
    config as _mod_config,
 
28
    controldir,
24
29
    debug,
25
30
    errors,
 
31
    gpg,
26
32
    graph,
 
33
    inventory_delta,
27
34
    lock,
28
35
    lockdir,
29
 
    repository,
 
36
    osutils,
 
37
    registry,
30
38
    repository as _mod_repository,
31
 
    revision,
32
39
    revision as _mod_revision,
33
40
    static_tuple,
34
 
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
 
from bzrlib.errors import (
 
41
    testament as _mod_testament,
 
42
    urlutils,
 
43
    vf_repository,
 
44
    vf_search,
 
45
    )
 
46
from .bzrbranch import BranchReferenceFormat
 
47
from .branch import BranchWriteLockResult
 
48
from .decorators import needs_read_lock, needs_write_lock, only_raises
 
49
from .errors import (
40
50
    NoSuchRevision,
41
51
    SmartProtocolError,
42
52
    )
43
 
from bzrlib.lockable_files import LockableFiles
44
 
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
 
from bzrlib.trace import mutter, note, warning
 
53
from .i18n import gettext
 
54
from .inventory import Inventory
 
55
from .inventorytree import InventoryRevisionTree
 
56
from .lockable_files import LockableFiles
 
57
from .sixish import (
 
58
    viewitems,
 
59
    viewvalues,
 
60
    )
 
61
from .smart import client, vfs, repository as smart_repo
 
62
from .smart.client import _SmartClient
 
63
from .revision import NULL_REVISION
 
64
from .repository import RepositoryWriteLockResult, _LazyListJoin
 
65
from .serializer import format_registry as serializer_format_registry
 
66
from .trace import mutter, note, warning, log_exception_quietly
 
67
from .versionedfile import FulltextContentFactory
 
68
 
 
69
 
 
70
_DEFAULT_SEARCH_DEPTH = 100
48
71
 
49
72
 
50
73
class _RpcHelper(object):
53
76
    def _call(self, method, *args, **err_context):
54
77
        try:
55
78
            return self._client.call(method, *args)
56
 
        except errors.ErrorFromSmartServer, err:
 
79
        except errors.ErrorFromSmartServer as err:
57
80
            self._translate_error(err, **err_context)
58
81
 
59
82
    def _call_expecting_body(self, method, *args, **err_context):
60
83
        try:
61
84
            return self._client.call_expecting_body(method, *args)
62
 
        except errors.ErrorFromSmartServer, err:
 
85
        except errors.ErrorFromSmartServer as err:
63
86
            self._translate_error(err, **err_context)
64
87
 
65
88
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
66
89
        try:
67
90
            return self._client.call_with_body_bytes(method, args, body_bytes)
68
 
        except errors.ErrorFromSmartServer, err:
 
91
        except errors.ErrorFromSmartServer as err:
69
92
            self._translate_error(err, **err_context)
70
93
 
71
94
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
73
96
        try:
74
97
            return self._client.call_with_body_bytes_expecting_body(
75
98
                method, args, body_bytes)
76
 
        except errors.ErrorFromSmartServer, err:
 
99
        except errors.ErrorFromSmartServer as err:
77
100
            self._translate_error(err, **err_context)
78
101
 
79
102
 
87
110
    return format
88
111
 
89
112
 
90
 
# Note: RemoteBzrDirFormat is in bzrdir.py
91
 
 
92
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
113
# Note that RemoteBzrDirProber lives in breezy.bzrdir so breezy.remote
 
114
# does not have to be imported unless a remote format is involved.
 
115
 
 
116
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
117
    """Format representing bzrdirs accessed via a smart server"""
 
118
 
 
119
    supports_workingtrees = False
 
120
 
 
121
    colocated_branches = False
 
122
 
 
123
    def __init__(self):
 
124
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
125
        # XXX: It's a bit ugly that the network name is here, because we'd
 
126
        # like to believe that format objects are stateless or at least
 
127
        # immutable,  However, we do at least avoid mutating the name after
 
128
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
129
        self._network_name = None
 
130
 
 
131
    def __repr__(self):
 
132
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
133
            self._network_name)
 
134
 
 
135
    def get_format_description(self):
 
136
        if self._network_name:
 
137
            try:
 
138
                real_format = controldir.network_format_registry.get(
 
139
                        self._network_name)
 
140
            except KeyError:
 
141
                pass
 
142
            else:
 
143
                return 'Remote: ' + real_format.get_format_description()
 
144
        return 'bzr remote bzrdir'
 
145
 
 
146
    def get_format_string(self):
 
147
        raise NotImplementedError(self.get_format_string)
 
148
 
 
149
    def network_name(self):
 
150
        if self._network_name:
 
151
            return self._network_name
 
152
        else:
 
153
            raise AssertionError("No network name set.")
 
154
 
 
155
    def initialize_on_transport(self, transport):
 
156
        try:
 
157
            # hand off the request to the smart server
 
158
            client_medium = transport.get_smart_medium()
 
159
        except errors.NoSmartMedium:
 
160
            # TODO: lookup the local format from a server hint.
 
161
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
162
            return local_dir_format.initialize_on_transport(transport)
 
163
        client = _SmartClient(client_medium)
 
164
        path = client.remote_path_from_transport(transport)
 
165
        try:
 
166
            response = client.call('BzrDirFormat.initialize', path)
 
167
        except errors.ErrorFromSmartServer as err:
 
168
            _translate_error(err, path=path)
 
169
        if response[0] != 'ok':
 
170
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
171
        format = RemoteBzrDirFormat()
 
172
        self._supply_sub_formats_to(format)
 
173
        return RemoteBzrDir(transport, format)
 
174
 
 
175
    def parse_NoneTrueFalse(self, arg):
 
176
        if not arg:
 
177
            return None
 
178
        if arg == 'False':
 
179
            return False
 
180
        if arg == 'True':
 
181
            return True
 
182
        raise AssertionError("invalid arg %r" % arg)
 
183
 
 
184
    def _serialize_NoneTrueFalse(self, arg):
 
185
        if arg is False:
 
186
            return 'False'
 
187
        if arg:
 
188
            return 'True'
 
189
        return ''
 
190
 
 
191
    def _serialize_NoneString(self, arg):
 
192
        return arg or ''
 
193
 
 
194
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
195
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
196
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
197
        shared_repo=False):
 
198
        try:
 
199
            # hand off the request to the smart server
 
200
            client_medium = transport.get_smart_medium()
 
201
        except errors.NoSmartMedium:
 
202
            do_vfs = True
 
203
        else:
 
204
            # Decline to open it if the server doesn't support our required
 
205
            # version (3) so that the VFS-based transport will do it.
 
206
            if client_medium.should_probe():
 
207
                try:
 
208
                    server_version = client_medium.protocol_version()
 
209
                    if server_version != '2':
 
210
                        do_vfs = True
 
211
                    else:
 
212
                        do_vfs = False
 
213
                except errors.SmartProtocolError:
 
214
                    # Apparently there's no usable smart server there, even though
 
215
                    # the medium supports the smart protocol.
 
216
                    do_vfs = True
 
217
            else:
 
218
                do_vfs = False
 
219
        if not do_vfs:
 
220
            client = _SmartClient(client_medium)
 
221
            path = client.remote_path_from_transport(transport)
 
222
            if client_medium._is_remote_before((1, 16)):
 
223
                do_vfs = True
 
224
        if do_vfs:
 
225
            # TODO: lookup the local format from a server hint.
 
226
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
227
            self._supply_sub_formats_to(local_dir_format)
 
228
            return local_dir_format.initialize_on_transport_ex(transport,
 
229
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
230
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
231
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
232
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
233
                vfs_only=True)
 
234
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
235
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
236
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
237
 
 
238
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
239
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
240
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
241
        args = []
 
242
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
243
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
244
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
245
        args.append(self._serialize_NoneString(stacked_on))
 
246
        # stack_on_pwd is often/usually our transport
 
247
        if stack_on_pwd:
 
248
            try:
 
249
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
250
                if not stack_on_pwd:
 
251
                    stack_on_pwd = '.'
 
252
            except errors.PathNotChild:
 
253
                pass
 
254
        args.append(self._serialize_NoneString(stack_on_pwd))
 
255
        args.append(self._serialize_NoneString(repo_format_name))
 
256
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
257
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
258
        request_network_name = self._network_name or \
 
259
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
260
        try:
 
261
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
262
                request_network_name, path, *args)
 
263
        except errors.UnknownSmartMethod:
 
264
            client._medium._remember_remote_is_before((1,16))
 
265
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
266
            self._supply_sub_formats_to(local_dir_format)
 
267
            return local_dir_format.initialize_on_transport_ex(transport,
 
268
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
269
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
270
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
271
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
272
                vfs_only=True)
 
273
        except errors.ErrorFromSmartServer as err:
 
274
            _translate_error(err, path=path)
 
275
        repo_path = response[0]
 
276
        bzrdir_name = response[6]
 
277
        require_stacking = response[7]
 
278
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
279
        format = RemoteBzrDirFormat()
 
280
        format._network_name = bzrdir_name
 
281
        self._supply_sub_formats_to(format)
 
282
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
283
        if repo_path:
 
284
            repo_format = response_tuple_to_repo_format(response[1:])
 
285
            if repo_path == '.':
 
286
                repo_path = ''
 
287
            if repo_path:
 
288
                repo_bzrdir_format = RemoteBzrDirFormat()
 
289
                repo_bzrdir_format._network_name = response[5]
 
290
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
291
                    repo_bzrdir_format)
 
292
            else:
 
293
                repo_bzr = bzrdir
 
294
            final_stack = response[8] or None
 
295
            final_stack_pwd = response[9] or None
 
296
            if final_stack_pwd:
 
297
                final_stack_pwd = urlutils.join(
 
298
                    transport.base, final_stack_pwd)
 
299
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
300
            if len(response) > 10:
 
301
                # Updated server verb that locks remotely.
 
302
                repo_lock_token = response[10] or None
 
303
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
304
                if repo_lock_token:
 
305
                    remote_repo.dont_leave_lock_in_place()
 
306
            else:
 
307
                remote_repo.lock_write()
 
308
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
309
                final_stack_pwd, require_stacking)
 
310
            policy.acquire_repository()
 
311
        else:
 
312
            remote_repo = None
 
313
            policy = None
 
314
        bzrdir._format.set_branch_format(self.get_branch_format())
 
315
        if require_stacking:
 
316
            # The repo has already been created, but we need to make sure that
 
317
            # we'll make a stackable branch.
 
318
            bzrdir._format.require_stacking(_skip_repo=True)
 
319
        return remote_repo, bzrdir, require_stacking, policy
 
320
 
 
321
    def _open(self, transport):
 
322
        return RemoteBzrDir(transport, self)
 
323
 
 
324
    def __eq__(self, other):
 
325
        if not isinstance(other, RemoteBzrDirFormat):
 
326
            return False
 
327
        return self.get_format_description() == other.get_format_description()
 
328
 
 
329
    def __return_repository_format(self):
 
330
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
331
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
332
        # that it should use that for init() etc.
 
333
        result = RemoteRepositoryFormat()
 
334
        custom_format = getattr(self, '_repository_format', None)
 
335
        if custom_format:
 
336
            if isinstance(custom_format, RemoteRepositoryFormat):
 
337
                return custom_format
 
338
            else:
 
339
                # We will use the custom format to create repositories over the
 
340
                # wire; expose its details like rich_root_data for code to
 
341
                # query
 
342
                result._custom_format = custom_format
 
343
        return result
 
344
 
 
345
    def get_branch_format(self):
 
346
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
347
        if not isinstance(result, RemoteBranchFormat):
 
348
            new_result = RemoteBranchFormat()
 
349
            new_result._custom_format = result
 
350
            # cache the result
 
351
            self.set_branch_format(new_result)
 
352
            result = new_result
 
353
        return result
 
354
 
 
355
    repository_format = property(__return_repository_format,
 
356
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
357
 
 
358
 
 
359
class RemoteControlStore(_mod_config.IniFileStore):
 
360
    """Control store which attempts to use HPSS calls to retrieve control store.
 
361
 
 
362
    Note that this is specific to bzr-based formats.
 
363
    """
 
364
 
 
365
    def __init__(self, bzrdir):
 
366
        super(RemoteControlStore, self).__init__()
 
367
        self.controldir = bzrdir
 
368
        self._real_store = None
 
369
 
 
370
    def lock_write(self, token=None):
 
371
        self._ensure_real()
 
372
        return self._real_store.lock_write(token)
 
373
 
 
374
    def unlock(self):
 
375
        self._ensure_real()
 
376
        return self._real_store.unlock()
 
377
 
 
378
    @needs_write_lock
 
379
    def save(self):
 
380
        # We need to be able to override the undecorated implementation
 
381
        self.save_without_locking()
 
382
 
 
383
    def save_without_locking(self):
 
384
        super(RemoteControlStore, self).save()
 
385
 
 
386
    def _ensure_real(self):
 
387
        self.controldir._ensure_real()
 
388
        if self._real_store is None:
 
389
            self._real_store = _mod_config.ControlStore(self.controldir)
 
390
 
 
391
    def external_url(self):
 
392
        return urlutils.join(self.branch.user_url, 'control.conf')
 
393
 
 
394
    def _load_content(self):
 
395
        medium = self.controldir._client._medium
 
396
        path = self.controldir._path_for_remote_call(self.controldir._client)
 
397
        try:
 
398
            response, handler = self.controldir._call_expecting_body(
 
399
                'BzrDir.get_config_file', path)
 
400
        except errors.UnknownSmartMethod:
 
401
            self._ensure_real()
 
402
            return self._real_store._load_content()
 
403
        if len(response) and response[0] != 'ok':
 
404
            raise errors.UnexpectedSmartServerResponse(response)
 
405
        return handler.read_body_bytes()
 
406
 
 
407
    def _save_content(self, content):
 
408
        # FIXME JRV 2011-11-22: Ideally this should use a
 
409
        # HPSS call too, but at the moment it is not possible
 
410
        # to write lock control directories.
 
411
        self._ensure_real()
 
412
        return self._real_store._save_content(content)
 
413
 
 
414
 
 
415
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
93
416
    """Control directory on a remote server, accessed via bzr:// or similar."""
94
417
 
95
418
    def __init__(self, transport, format, _client=None, _force_probe=False):
98
421
        :param _client: Private parameter for testing. Disables probing and the
99
422
            use of a real bzrdir.
100
423
        """
101
 
        BzrDir.__init__(self, transport, format)
 
424
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
102
425
        # this object holds a delegated bzrdir that uses file-level operations
103
426
        # to talk to the other side
104
427
        self._real_bzrdir = None
164
487
                import traceback
165
488
                warning('VFS BzrDir access triggered\n%s',
166
489
                    ''.join(traceback.format_stack()))
167
 
            self._real_bzrdir = BzrDir.open_from_transport(
168
 
                self.root_transport, _server_formats=False)
 
490
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
491
                self.root_transport, probers=[_mod_bzrdir.BzrProber])
169
492
            self._format._network_name = \
170
493
                self._real_bzrdir._format.network_name()
171
494
 
176
499
        # Prevent aliasing problems in the next_open_branch_result cache.
177
500
        # See create_branch for rationale.
178
501
        self._next_open_branch_result = None
179
 
        return BzrDir.break_lock(self)
 
502
        return _mod_bzrdir.BzrDir.break_lock(self)
 
503
 
 
504
    def _vfs_checkout_metadir(self):
 
505
        self._ensure_real()
 
506
        return self._real_bzrdir.checkout_metadir()
 
507
 
 
508
    def checkout_metadir(self):
 
509
        """Retrieve the controldir format to use for checkouts of this one.
 
510
        """
 
511
        medium = self._client._medium
 
512
        if medium._is_remote_before((2, 5)):
 
513
            return self._vfs_checkout_metadir()
 
514
        path = self._path_for_remote_call(self._client)
 
515
        try:
 
516
            response = self._client.call('BzrDir.checkout_metadir',
 
517
                path)
 
518
        except errors.UnknownSmartMethod:
 
519
            medium._remember_remote_is_before((2, 5))
 
520
            return self._vfs_checkout_metadir()
 
521
        if len(response) != 3:
 
522
            raise errors.UnexpectedSmartServerResponse(response)
 
523
        control_name, repo_name, branch_name = response
 
524
        try:
 
525
            format = controldir.network_format_registry.get(control_name)
 
526
        except KeyError:
 
527
            raise errors.UnknownFormatError(kind='control',
 
528
                format=control_name)
 
529
        if repo_name:
 
530
            try:
 
531
                repo_format = _mod_repository.network_format_registry.get(
 
532
                    repo_name)
 
533
            except KeyError:
 
534
                raise errors.UnknownFormatError(kind='repository',
 
535
                    format=repo_name)
 
536
            format.repository_format = repo_format
 
537
        if branch_name:
 
538
            try:
 
539
                format.set_branch_format(
 
540
                    branch.network_format_registry.get(branch_name))
 
541
            except KeyError:
 
542
                raise errors.UnknownFormatError(kind='branch',
 
543
                    format=branch_name)
 
544
        return format
180
545
 
181
546
    def _vfs_cloning_metadir(self, require_stacking=False):
182
547
        self._ensure_real()
198
563
        except errors.UnknownSmartMethod:
199
564
            medium._remember_remote_is_before((1, 13))
200
565
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
201
 
        except errors.UnknownErrorFromSmartServer, err:
 
566
        except errors.UnknownErrorFromSmartServer as err:
202
567
            if err.error_tuple != ('BranchReference',):
203
568
                raise
204
569
            # We need to resolve the branch reference to determine the
206
571
            # referenced branch (and bzrdir, etc) but only when the caller
207
572
            # didn't already resolve the branch reference.
208
573
            referenced_branch = self.open_branch()
209
 
            return referenced_branch.bzrdir.cloning_metadir()
 
574
            return referenced_branch.controldir.cloning_metadir()
210
575
        if len(response) != 3:
211
576
            raise errors.UnexpectedSmartServerResponse(response)
212
577
        control_name, repo_name, branch_info = response
213
578
        if len(branch_info) != 2:
214
579
            raise errors.UnexpectedSmartServerResponse(response)
215
580
        branch_ref, branch_name = branch_info
216
 
        format = bzrdir.network_format_registry.get(control_name)
 
581
        try:
 
582
            format = controldir.network_format_registry.get(control_name)
 
583
        except KeyError:
 
584
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
585
 
217
586
        if repo_name:
218
 
            format.repository_format = repository.network_format_registry.get(
219
 
                repo_name)
 
587
            try:
 
588
                format.repository_format = _mod_repository.network_format_registry.get(
 
589
                    repo_name)
 
590
            except KeyError:
 
591
                raise errors.UnknownFormatError(kind='repository',
 
592
                    format=repo_name)
220
593
        if branch_ref == 'ref':
221
594
            # XXX: we need possible_transports here to avoid reopening the
222
595
            # connection to the referenced location
223
 
            ref_bzrdir = BzrDir.open(branch_name)
 
596
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
224
597
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
598
            format.set_branch_format(branch_format)
226
599
        elif branch_ref == 'branch':
227
600
            if branch_name:
228
 
                format.set_branch_format(
229
 
                    branch.network_format_registry.get(branch_name))
 
601
                try:
 
602
                    branch_format = branch.network_format_registry.get(
 
603
                        branch_name)
 
604
                except KeyError:
 
605
                    raise errors.UnknownFormatError(kind='branch',
 
606
                        format=branch_name)
 
607
                format.set_branch_format(branch_format)
230
608
        else:
231
609
            raise errors.UnexpectedSmartServerResponse(response)
232
610
        return format
242
620
 
243
621
    def destroy_repository(self):
244
622
        """See BzrDir.destroy_repository"""
245
 
        self._ensure_real()
246
 
        self._real_bzrdir.destroy_repository()
 
623
        path = self._path_for_remote_call(self._client)
 
624
        try:
 
625
            response = self._call('BzrDir.destroy_repository', path)
 
626
        except errors.UnknownSmartMethod:
 
627
            self._ensure_real()
 
628
            self._real_bzrdir.destroy_repository()
 
629
            return
 
630
        if response[0] != 'ok':
 
631
            raise SmartProtocolError('unexpected response code %s' % (response,))
247
632
 
248
 
    def create_branch(self, name=None):
 
633
    def create_branch(self, name=None, repository=None,
 
634
                      append_revisions_only=None):
 
635
        if name is None:
 
636
            name = self._get_selected_branch()
 
637
        if name != "":
 
638
            raise errors.NoColocatedBranchSupport(self)
249
639
        # as per meta1 formats - just delegate to the format object which may
250
640
        # be parameterised.
251
641
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
642
            name=name, repository=repository,
 
643
            append_revisions_only=append_revisions_only)
253
644
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
645
            if not isinstance(repository, RemoteRepository):
 
646
                raise AssertionError(
 
647
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
648
                    % (repository,))
 
649
            result = RemoteBranch(self, repository, real_branch, name=name)
256
650
        else:
257
651
            result = real_branch
258
652
        # BzrDir.clone_on_transport() uses the result of create_branch but does
266
660
 
267
661
    def destroy_branch(self, name=None):
268
662
        """See BzrDir.destroy_branch"""
269
 
        self._ensure_real()
270
 
        self._real_bzrdir.destroy_branch(name=name)
 
663
        if name is None:
 
664
            name = self._get_selected_branch()
 
665
        if name != "":
 
666
            raise errors.NoColocatedBranchSupport(self)
 
667
        path = self._path_for_remote_call(self._client)
 
668
        try:
 
669
            if name != "":
 
670
                args = (name, )
 
671
            else:
 
672
                args = ()
 
673
            response = self._call('BzrDir.destroy_branch', path, *args)
 
674
        except errors.UnknownSmartMethod:
 
675
            self._ensure_real()
 
676
            self._real_bzrdir.destroy_branch(name=name)
 
677
            self._next_open_branch_result = None
 
678
            return
271
679
        self._next_open_branch_result = None
 
680
        if response[0] != 'ok':
 
681
            raise SmartProtocolError('unexpected response code %s' % (response,))
272
682
 
273
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
683
    def create_workingtree(self, revision_id=None, from_branch=None,
 
684
        accelerator_tree=None, hardlink=False):
274
685
        raise errors.NotLocalUrl(self.transport.base)
275
686
 
276
687
    def find_branch_format(self, name=None):
281
692
        b = self.open_branch(name=name)
282
693
        return b._format
283
694
 
 
695
    def get_branches(self, possible_transports=None, ignore_fallbacks=False):
 
696
        path = self._path_for_remote_call(self._client)
 
697
        try:
 
698
            response, handler = self._call_expecting_body(
 
699
                'BzrDir.get_branches', path)
 
700
        except errors.UnknownSmartMethod:
 
701
            self._ensure_real()
 
702
            return self._real_bzrdir.get_branches()
 
703
        if response[0] != "success":
 
704
            raise errors.UnexpectedSmartServerResponse(response)
 
705
        body = bencode.bdecode(handler.read_body_bytes())
 
706
        ret = {}
 
707
        for name, value in viewitems(body):
 
708
            ret[name] = self._open_branch(name, value[0], value[1],
 
709
                possible_transports=possible_transports,
 
710
                ignore_fallbacks=ignore_fallbacks)
 
711
        return ret
 
712
 
 
713
    def set_branch_reference(self, target_branch, name=None):
 
714
        """See BzrDir.set_branch_reference()."""
 
715
        if name is None:
 
716
            name = self._get_selected_branch()
 
717
        if name != "":
 
718
            raise errors.NoColocatedBranchSupport(self)
 
719
        self._ensure_real()
 
720
        return self._real_bzrdir.set_branch_reference(target_branch, name=name)
 
721
 
284
722
    def get_branch_reference(self, name=None):
285
723
        """See BzrDir.get_branch_reference()."""
286
 
        if name is not None:
287
 
            # XXX JRV20100304: Support opening colocated branches
 
724
        if name is None:
 
725
            name = self._get_selected_branch()
 
726
        if name != "":
288
727
            raise errors.NoColocatedBranchSupport(self)
289
728
        response = self._get_branch_reference()
290
729
        if response[0] == 'ref':
326
765
        """See BzrDir._get_tree_branch()."""
327
766
        return None, self.open_branch(name=name)
328
767
 
329
 
    def open_branch(self, name=None, unsupported=False,
330
 
                    ignore_fallbacks=False):
331
 
        if unsupported:
332
 
            raise NotImplementedError('unsupported flag support not implemented yet.')
333
 
        if self._next_open_branch_result is not None:
334
 
            # See create_branch for details.
335
 
            result = self._next_open_branch_result
336
 
            self._next_open_branch_result = None
337
 
            return result
338
 
        response = self._get_branch_reference()
339
 
        if response[0] == 'ref':
 
768
    def _open_branch(self, name, kind, location_or_format,
 
769
                     ignore_fallbacks=False, possible_transports=None):
 
770
        if kind == 'ref':
340
771
            # a branch reference, use the existing BranchReference logic.
341
772
            format = BranchReferenceFormat()
342
773
            return format.open(self, name=name, _found=True,
343
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
344
 
        branch_format_name = response[1]
 
774
                location=location_or_format, ignore_fallbacks=ignore_fallbacks,
 
775
                possible_transports=possible_transports)
 
776
        branch_format_name = location_or_format
345
777
        if not branch_format_name:
346
778
            branch_format_name = None
347
779
        format = RemoteBranchFormat(network_name=branch_format_name)
348
780
        return RemoteBranch(self, self.find_repository(), format=format,
349
 
            setup_stacking=not ignore_fallbacks, name=name)
 
781
            setup_stacking=not ignore_fallbacks, name=name,
 
782
            possible_transports=possible_transports)
 
783
 
 
784
    def open_branch(self, name=None, unsupported=False,
 
785
                    ignore_fallbacks=False, possible_transports=None):
 
786
        if name is None:
 
787
            name = self._get_selected_branch()
 
788
        if name != "":
 
789
            raise errors.NoColocatedBranchSupport(self)
 
790
        if unsupported:
 
791
            raise NotImplementedError('unsupported flag support not implemented yet.')
 
792
        if self._next_open_branch_result is not None:
 
793
            # See create_branch for details.
 
794
            result = self._next_open_branch_result
 
795
            self._next_open_branch_result = None
 
796
            return result
 
797
        response = self._get_branch_reference()
 
798
        return self._open_branch(name, response[0], response[1],
 
799
            possible_transports=possible_transports,
 
800
            ignore_fallbacks=ignore_fallbacks)
350
801
 
351
802
    def _open_repo_v1(self, path):
352
803
        verb = 'BzrDir.find_repository'
415
866
 
416
867
    def has_workingtree(self):
417
868
        if self._has_working_tree is None:
418
 
            self._ensure_real()
419
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
869
            path = self._path_for_remote_call(self._client)
 
870
            try:
 
871
                response = self._call('BzrDir.has_workingtree', path)
 
872
            except errors.UnknownSmartMethod:
 
873
                self._ensure_real()
 
874
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
875
            else:
 
876
                if response[0] not in ('yes', 'no'):
 
877
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
878
                self._has_working_tree = (response[0] == 'yes')
420
879
        return self._has_working_tree
421
880
 
422
881
    def open_workingtree(self, recommend_upgrade=True):
427
886
 
428
887
    def _path_for_remote_call(self, client):
429
888
        """Return the path to be used for this bzrdir in a remote call."""
430
 
        return client.remote_path_from_transport(self.root_transport)
 
889
        return urlutils.split_segment_parameters_raw(
 
890
            client.remote_path_from_transport(self.root_transport))[0]
431
891
 
432
892
    def get_branch_transport(self, branch_format, name=None):
433
893
        self._ensure_real()
445
905
        """Upgrading of remote bzrdirs is not supported yet."""
446
906
        return False
447
907
 
448
 
    def needs_format_conversion(self, format=None):
 
908
    def needs_format_conversion(self, format):
449
909
        """Upgrading of remote bzrdirs is not supported yet."""
450
 
        if format is None:
451
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
452
 
                % 'needs_format_conversion(format=None)')
453
910
        return False
454
911
 
455
 
    def clone(self, url, revision_id=None, force_new_repo=False,
456
 
              preserve_stacking=False):
457
 
        self._ensure_real()
458
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
459
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
460
 
 
461
912
    def _get_config(self):
462
913
        return RemoteBzrDirConfig(self)
463
914
 
464
 
 
465
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
915
    def _get_config_store(self):
 
916
        return RemoteControlStore(self)
 
917
 
 
918
 
 
919
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
466
920
    """Format for repositories accessed over a _SmartClient.
467
921
 
468
922
    Instances of this repository are represented by RemoteRepository
483
937
    """
484
938
 
485
939
    _matchingbzrdir = RemoteBzrDirFormat()
 
940
    supports_full_versioned_files = True
 
941
    supports_leaving_lock = True
486
942
 
487
943
    def __init__(self):
488
 
        repository.RepositoryFormat.__init__(self)
 
944
        _mod_repository.RepositoryFormat.__init__(self)
489
945
        self._custom_format = None
490
946
        self._network_name = None
491
947
        self._creating_bzrdir = None
 
948
        self._revision_graph_can_have_wrong_parents = None
492
949
        self._supports_chks = None
493
950
        self._supports_external_lookups = None
494
951
        self._supports_tree_reference = None
 
952
        self._supports_funky_characters = None
 
953
        self._supports_nesting_repositories = None
495
954
        self._rich_root_data = None
496
955
 
497
956
    def __repr__(self):
526
985
        return self._supports_external_lookups
527
986
 
528
987
    @property
 
988
    def supports_funky_characters(self):
 
989
        if self._supports_funky_characters is None:
 
990
            self._ensure_real()
 
991
            self._supports_funky_characters = \
 
992
                self._custom_format.supports_funky_characters
 
993
        return self._supports_funky_characters
 
994
 
 
995
    @property
 
996
    def supports_nesting_repositories(self):
 
997
        if self._supports_nesting_repositories is None:
 
998
            self._ensure_real()
 
999
            self._supports_nesting_repositories = \
 
1000
                self._custom_format.supports_nesting_repositories
 
1001
        return self._supports_nesting_repositories
 
1002
 
 
1003
    @property
529
1004
    def supports_tree_reference(self):
530
1005
        if self._supports_tree_reference is None:
531
1006
            self._ensure_real()
533
1008
                self._custom_format.supports_tree_reference
534
1009
        return self._supports_tree_reference
535
1010
 
536
 
    def _vfs_initialize(self, a_bzrdir, shared):
 
1011
    @property
 
1012
    def revision_graph_can_have_wrong_parents(self):
 
1013
        if self._revision_graph_can_have_wrong_parents is None:
 
1014
            self._ensure_real()
 
1015
            self._revision_graph_can_have_wrong_parents = \
 
1016
                self._custom_format.revision_graph_can_have_wrong_parents
 
1017
        return self._revision_graph_can_have_wrong_parents
 
1018
 
 
1019
    def _vfs_initialize(self, a_controldir, shared):
537
1020
        """Helper for common code in initialize."""
538
1021
        if self._custom_format:
539
1022
            # Custom format requested
540
 
            result = self._custom_format.initialize(a_bzrdir, shared=shared)
 
1023
            result = self._custom_format.initialize(a_controldir, shared=shared)
541
1024
        elif self._creating_bzrdir is not None:
542
1025
            # Use the format that the repository we were created to back
543
1026
            # has.
544
1027
            prior_repo = self._creating_bzrdir.open_repository()
545
1028
            prior_repo._ensure_real()
546
1029
            result = prior_repo._real_repository._format.initialize(
547
 
                a_bzrdir, shared=shared)
 
1030
                a_controldir, shared=shared)
548
1031
        else:
549
1032
            # assume that a_bzr is a RemoteBzrDir but the smart server didn't
550
1033
            # support remote initialization.
551
1034
            # We delegate to a real object at this point (as RemoteBzrDir
552
1035
            # delegate to the repository format which would lead to infinite
553
 
            # recursion if we just called a_bzrdir.create_repository.
554
 
            a_bzrdir._ensure_real()
555
 
            result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
 
1036
            # recursion if we just called a_controldir.create_repository.
 
1037
            a_controldir._ensure_real()
 
1038
            result = a_controldir._real_bzrdir.create_repository(shared=shared)
556
1039
        if not isinstance(result, RemoteRepository):
557
 
            return self.open(a_bzrdir)
 
1040
            return self.open(a_controldir)
558
1041
        else:
559
1042
            return result
560
1043
 
561
 
    def initialize(self, a_bzrdir, shared=False):
 
1044
    def initialize(self, a_controldir, shared=False):
562
1045
        # Being asked to create on a non RemoteBzrDir:
563
 
        if not isinstance(a_bzrdir, RemoteBzrDir):
564
 
            return self._vfs_initialize(a_bzrdir, shared)
565
 
        medium = a_bzrdir._client._medium
 
1046
        if not isinstance(a_controldir, RemoteBzrDir):
 
1047
            return self._vfs_initialize(a_controldir, shared)
 
1048
        medium = a_controldir._client._medium
566
1049
        if medium._is_remote_before((1, 13)):
567
 
            return self._vfs_initialize(a_bzrdir, shared)
 
1050
            return self._vfs_initialize(a_controldir, shared)
568
1051
        # Creating on a remote bzr dir.
569
1052
        # 1) get the network name to use.
570
1053
        if self._custom_format:
572
1055
        elif self._network_name:
573
1056
            network_name = self._network_name
574
1057
        else:
575
 
            # Select the current bzrlib default and ask for that.
576
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1058
            # Select the current breezy default and ask for that.
 
1059
            reference_bzrdir_format = controldir.format_registry.get('default')()
577
1060
            reference_format = reference_bzrdir_format.repository_format
578
1061
            network_name = reference_format.network_name()
579
1062
        # 2) try direct creation via RPC
580
 
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
1063
        path = a_controldir._path_for_remote_call(a_controldir._client)
581
1064
        verb = 'BzrDir.create_repository'
582
1065
        if shared:
583
1066
            shared_str = 'True'
584
1067
        else:
585
1068
            shared_str = 'False'
586
1069
        try:
587
 
            response = a_bzrdir._call(verb, path, network_name, shared_str)
 
1070
            response = a_controldir._call(verb, path, network_name, shared_str)
588
1071
        except errors.UnknownSmartMethod:
589
1072
            # Fallback - use vfs methods
590
1073
            medium._remember_remote_is_before((1, 13))
591
 
            return self._vfs_initialize(a_bzrdir, shared)
 
1074
            return self._vfs_initialize(a_controldir, shared)
592
1075
        else:
593
1076
            # Turn the response into a RemoteRepository object.
594
1077
            format = response_tuple_to_repo_format(response[1:])
595
1078
            # Used to support creating a real format instance when needed.
596
 
            format._creating_bzrdir = a_bzrdir
597
 
            remote_repo = RemoteRepository(a_bzrdir, format)
 
1079
            format._creating_bzrdir = a_controldir
 
1080
            remote_repo = RemoteRepository(a_controldir, format)
598
1081
            format._creating_repo = remote_repo
599
1082
            return remote_repo
600
1083
 
601
 
    def open(self, a_bzrdir):
602
 
        if not isinstance(a_bzrdir, RemoteBzrDir):
603
 
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
604
 
        return a_bzrdir.open_repository()
 
1084
    def open(self, a_controldir):
 
1085
        if not isinstance(a_controldir, RemoteBzrDir):
 
1086
            raise AssertionError('%r is not a RemoteBzrDir' % (a_controldir,))
 
1087
        return a_controldir.open_repository()
605
1088
 
606
1089
    def _ensure_real(self):
607
1090
        if self._custom_format is None:
608
 
            self._custom_format = repository.network_format_registry.get(
609
 
                self._network_name)
 
1091
            try:
 
1092
                self._custom_format = _mod_repository.network_format_registry.get(
 
1093
                    self._network_name)
 
1094
            except KeyError:
 
1095
                raise errors.UnknownFormatError(kind='repository',
 
1096
                    format=self._network_name)
610
1097
 
611
1098
    @property
612
1099
    def _fetch_order(self):
647
1134
        return self._custom_format._serializer
648
1135
 
649
1136
 
650
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
 
    bzrdir.ControlComponent):
 
1137
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1138
        lock._RelockDebugMixin):
652
1139
    """Repository accessed over rpc.
653
1140
 
654
1141
    For the moment most operations are performed using local transport-backed
670
1157
            self._real_repository = real_repository
671
1158
        else:
672
1159
            self._real_repository = None
673
 
        self.bzrdir = remote_bzrdir
 
1160
        self.controldir = remote_bzrdir
674
1161
        if _client is None:
675
1162
            self._client = remote_bzrdir._client
676
1163
        else:
678
1165
        self._format = format
679
1166
        self._lock_mode = None
680
1167
        self._lock_token = None
 
1168
        self._write_group_tokens = None
681
1169
        self._lock_count = 0
682
1170
        self._leave_lock = False
683
1171
        # Cache of revision parents; misses are cached during read locks, and
693
1181
        self._reconcile_does_inventory_gc = False
694
1182
        self._reconcile_fixes_text_parents = False
695
1183
        self._reconcile_backsup_inventory = False
696
 
        self.base = self.bzrdir.transport.base
 
1184
        self.base = self.controldir.transport.base
697
1185
        # Additional places to query for data.
698
1186
        self._fallback_repositories = []
699
1187
 
700
1188
    @property
701
1189
    def user_transport(self):
702
 
        return self.bzrdir.user_transport
 
1190
        return self.controldir.user_transport
703
1191
 
704
1192
    @property
705
1193
    def control_transport(self):
706
1194
        # XXX: Normally you shouldn't directly get at the remote repository
707
1195
        # transport, but I'm not sure it's worth making this method
708
1196
        # optional -- mbp 2010-04-21
709
 
        return self.bzrdir.get_repository_transport(None)
710
 
        
 
1197
        return self.controldir.get_repository_transport(None)
 
1198
 
711
1199
    def __str__(self):
712
1200
        return "%s(%s)" % (self.__class__.__name__, self.base)
713
1201
 
723
1211
 
724
1212
        :param suppress_errors: see Repository.abort_write_group.
725
1213
        """
726
 
        self._ensure_real()
727
 
        return self._real_repository.abort_write_group(
728
 
            suppress_errors=suppress_errors)
 
1214
        if self._real_repository:
 
1215
            self._ensure_real()
 
1216
            return self._real_repository.abort_write_group(
 
1217
                suppress_errors=suppress_errors)
 
1218
        if not self.is_in_write_group():
 
1219
            if suppress_errors:
 
1220
                mutter('(suppressed) not in write group')
 
1221
                return
 
1222
            raise errors.BzrError("not in write group")
 
1223
        path = self.controldir._path_for_remote_call(self._client)
 
1224
        try:
 
1225
            response = self._call('Repository.abort_write_group', path,
 
1226
                self._lock_token, self._write_group_tokens)
 
1227
        except Exception as exc:
 
1228
            self._write_group = None
 
1229
            if not suppress_errors:
 
1230
                raise
 
1231
            mutter('abort_write_group failed')
 
1232
            log_exception_quietly()
 
1233
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1234
        else:
 
1235
            if response != ('ok', ):
 
1236
                raise errors.UnexpectedSmartServerResponse(response)
 
1237
            self._write_group_tokens = None
729
1238
 
730
1239
    @property
731
1240
    def chk_bytes(self):
745
1254
        for older plugins that don't use e.g. the CommitBuilder
746
1255
        facility.
747
1256
        """
748
 
        self._ensure_real()
749
 
        return self._real_repository.commit_write_group()
 
1257
        if self._real_repository:
 
1258
            self._ensure_real()
 
1259
            return self._real_repository.commit_write_group()
 
1260
        if not self.is_in_write_group():
 
1261
            raise errors.BzrError("not in write group")
 
1262
        path = self.controldir._path_for_remote_call(self._client)
 
1263
        response = self._call('Repository.commit_write_group', path,
 
1264
            self._lock_token, self._write_group_tokens)
 
1265
        if response != ('ok', ):
 
1266
            raise errors.UnexpectedSmartServerResponse(response)
 
1267
        self._write_group_tokens = None
 
1268
        # Refresh data after writing to the repository.
 
1269
        self.refresh_data()
750
1270
 
751
1271
    def resume_write_group(self, tokens):
752
 
        self._ensure_real()
753
 
        return self._real_repository.resume_write_group(tokens)
 
1272
        if self._real_repository:
 
1273
            return self._real_repository.resume_write_group(tokens)
 
1274
        path = self.controldir._path_for_remote_call(self._client)
 
1275
        try:
 
1276
            response = self._call('Repository.check_write_group', path,
 
1277
               self._lock_token, tokens)
 
1278
        except errors.UnknownSmartMethod:
 
1279
            self._ensure_real()
 
1280
            return self._real_repository.resume_write_group(tokens)
 
1281
        if response != ('ok', ):
 
1282
            raise errors.UnexpectedSmartServerResponse(response)
 
1283
        self._write_group_tokens = tokens
754
1284
 
755
1285
    def suspend_write_group(self):
756
 
        self._ensure_real()
757
 
        return self._real_repository.suspend_write_group()
 
1286
        if self._real_repository:
 
1287
            return self._real_repository.suspend_write_group()
 
1288
        ret = self._write_group_tokens or []
 
1289
        self._write_group_tokens = None
 
1290
        return ret
758
1291
 
759
1292
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
760
1293
        self._ensure_real()
768
1301
 
769
1302
    def get_rev_id_for_revno(self, revno, known_pair):
770
1303
        """See Repository.get_rev_id_for_revno."""
771
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1304
        path = self.controldir._path_for_remote_call(self._client)
772
1305
        try:
773
1306
            if self._client._medium._is_remote_before((1, 17)):
774
1307
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
811
1344
                warning('VFS Repository access triggered\n%s',
812
1345
                    ''.join(traceback.format_stack()))
813
1346
            self._unstacked_provider.missing_keys.clear()
814
 
            self.bzrdir._ensure_real()
 
1347
            self.controldir._ensure_real()
815
1348
            self._set_real_repository(
816
 
                self.bzrdir._real_bzrdir.open_repository())
 
1349
                self.controldir._real_bzrdir.open_repository())
817
1350
 
818
1351
    def _translate_error(self, err, **context):
819
 
        self.bzrdir._translate_error(err, repository=self, **context)
 
1352
        self.controldir._translate_error(err, repository=self, **context)
820
1353
 
821
1354
    def find_text_key_references(self):
822
1355
        """Find the text key references within the repository.
823
1356
 
824
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
825
 
        revision_ids. Each altered file-ids has the exact revision_ids that
826
 
        altered it listed explicitly.
827
1357
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
828
1358
            to whether they were referred to by the inventory of the
829
1359
            revision_id that they contain. The inventory texts from all present
847
1377
        """Private method for using with old (< 1.2) servers to fallback."""
848
1378
        if revision_id is None:
849
1379
            revision_id = ''
850
 
        elif revision.is_null(revision_id):
 
1380
        elif _mod_revision.is_null(revision_id):
851
1381
            return {}
852
1382
 
853
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1383
        path = self.controldir._path_for_remote_call(self._client)
854
1384
        response = self._call_expecting_body(
855
1385
            'Repository.get_revision_graph', path, revision_id)
856
1386
        response_tuple, response_handler = response
877
1407
        return RemoteStreamSource(self, to_format)
878
1408
 
879
1409
    @needs_read_lock
 
1410
    def get_file_graph(self):
 
1411
        return graph.Graph(self.texts)
 
1412
 
 
1413
    @needs_read_lock
880
1414
    def has_revision(self, revision_id):
881
1415
        """True if this repository has a copy of the revision."""
882
 
        # Copy of bzrlib.repository.Repository.has_revision
 
1416
        # Copy of breezy.repository.Repository.has_revision
883
1417
        return revision_id in self.has_revisions((revision_id,))
884
1418
 
885
1419
    @needs_read_lock
889
1423
        :param revision_ids: An iterable of revision_ids.
890
1424
        :return: A set of the revision_ids that were present.
891
1425
        """
892
 
        # Copy of bzrlib.repository.Repository.has_revisions
 
1426
        # Copy of breezy.repository.Repository.has_revisions
893
1427
        parent_map = self.get_parent_map(revision_ids)
894
1428
        result = set(parent_map)
895
1429
        if _mod_revision.NULL_REVISION in revision_ids:
899
1433
    def _has_same_fallbacks(self, other_repo):
900
1434
        """Returns true if the repositories have the same fallbacks."""
901
1435
        # XXX: copied from Repository; it should be unified into a base class
902
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1436
        # <https://bugs.launchpad.net/bzr/+bug/401622>
903
1437
        my_fb = self._fallback_repositories
904
1438
        other_fb = other_repo._fallback_repositories
905
1439
        if len(my_fb) != len(other_fb):
914
1448
        # one; unfortunately the tests rely on slightly different behaviour at
915
1449
        # present -- mbp 20090710
916
1450
        return (self.__class__ is other.__class__ and
917
 
                self.bzrdir.transport.base == other.bzrdir.transport.base)
 
1451
                self.controldir.transport.base == other.controldir.transport.base)
918
1452
 
919
1453
    def get_graph(self, other_repository=None):
920
1454
        """Return the graph for this repository format"""
932
1466
 
933
1467
    def gather_stats(self, revid=None, committers=None):
934
1468
        """See Repository.gather_stats()."""
935
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1469
        path = self.controldir._path_for_remote_call(self._client)
936
1470
        # revid can be None to indicate no revisions, not just NULL_REVISION
937
 
        if revid is None or revision.is_null(revid):
 
1471
        if revid is None or _mod_revision.is_null(revid):
938
1472
            fmt_revid = ''
939
1473
        else:
940
1474
            fmt_revid = revid
957
1491
                result[key] = int(val_text)
958
1492
            elif key in ('firstrev', 'latestrev'):
959
1493
                values = val_text.split(' ')[1:]
960
 
                result[key] = (float(values[0]), long(values[1]))
 
1494
                result[key] = (float(values[0]), int(values[1]))
961
1495
 
962
1496
        return result
963
1497
 
969
1503
 
970
1504
    def get_physical_lock_status(self):
971
1505
        """See Repository.get_physical_lock_status()."""
972
 
        # should be an API call to the server.
973
 
        self._ensure_real()
974
 
        return self._real_repository.get_physical_lock_status()
 
1506
        path = self.controldir._path_for_remote_call(self._client)
 
1507
        try:
 
1508
            response = self._call('Repository.get_physical_lock_status', path)
 
1509
        except errors.UnknownSmartMethod:
 
1510
            self._ensure_real()
 
1511
            return self._real_repository.get_physical_lock_status()
 
1512
        if response[0] not in ('yes', 'no'):
 
1513
            raise errors.UnexpectedSmartServerResponse(response)
 
1514
        return (response[0] == 'yes')
975
1515
 
976
1516
    def is_in_write_group(self):
977
1517
        """Return True if there is an open write group.
978
1518
 
979
1519
        write groups are only applicable locally for the smart server..
980
1520
        """
 
1521
        if self._write_group_tokens is not None:
 
1522
            return True
981
1523
        if self._real_repository:
982
1524
            return self._real_repository.is_in_write_group()
983
1525
 
986
1528
 
987
1529
    def is_shared(self):
988
1530
        """See Repository.is_shared()."""
989
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1531
        path = self.controldir._path_for_remote_call(self._client)
990
1532
        response = self._call('Repository.is_shared', path)
991
1533
        if response[0] not in ('yes', 'no'):
992
1534
            raise SmartProtocolError('unexpected response code %s' % (response,))
1003
1545
    def lock_read(self):
1004
1546
        """Lock the repository for read operations.
1005
1547
 
1006
 
        :return: A bzrlib.lock.LogicalLockResult.
 
1548
        :return: A breezy.lock.LogicalLockResult.
1007
1549
        """
1008
1550
        # wrong eventually - want a local lock cache context
1009
1551
        if not self._lock_mode:
1020
1562
        return lock.LogicalLockResult(self.unlock)
1021
1563
 
1022
1564
    def _remote_lock_write(self, token):
1023
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1565
        path = self.controldir._path_for_remote_call(self._client)
1024
1566
        if token is None:
1025
1567
            token = ''
1026
1568
        err_context = {'token': token}
1118
1660
            self._real_repository.lock_write(self._lock_token)
1119
1661
        elif self._lock_mode == 'r':
1120
1662
            self._real_repository.lock_read()
 
1663
        if self._write_group_tokens is not None:
 
1664
            # if we are already in a write group, resume it
 
1665
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1666
            self._write_group_tokens = None
1121
1667
 
1122
1668
    def start_write_group(self):
1123
1669
        """Start a write group on the decorated repository.
1127
1673
        for older plugins that don't use e.g. the CommitBuilder
1128
1674
        facility.
1129
1675
        """
1130
 
        self._ensure_real()
1131
 
        return self._real_repository.start_write_group()
 
1676
        if self._real_repository:
 
1677
            self._ensure_real()
 
1678
            return self._real_repository.start_write_group()
 
1679
        if not self.is_write_locked():
 
1680
            raise errors.NotWriteLocked(self)
 
1681
        if self._write_group_tokens is not None:
 
1682
            raise errors.BzrError('already in a write group')
 
1683
        path = self.controldir._path_for_remote_call(self._client)
 
1684
        try:
 
1685
            response = self._call('Repository.start_write_group', path,
 
1686
                self._lock_token)
 
1687
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1688
            self._ensure_real()
 
1689
            return self._real_repository.start_write_group()
 
1690
        if response[0] != 'ok':
 
1691
            raise errors.UnexpectedSmartServerResponse(response)
 
1692
        self._write_group_tokens = response[1]
1132
1693
 
1133
1694
    def _unlock(self, token):
1134
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1695
        path = self.controldir._path_for_remote_call(self._client)
1135
1696
        if not token:
1136
1697
            # with no token the remote repository is not persistently locked.
1137
1698
            return
1161
1722
            # This is just to let the _real_repository stay up to date.
1162
1723
            if self._real_repository is not None:
1163
1724
                self._real_repository.unlock()
 
1725
            elif self._write_group_tokens is not None:
 
1726
                self.abort_write_group()
1164
1727
        finally:
1165
1728
            # The rpc-level lock should be released even if there was a
1166
1729
            # problem releasing the vfs-based lock.
1178
1741
 
1179
1742
    def break_lock(self):
1180
1743
        # should hand off to the network
1181
 
        self._ensure_real()
1182
 
        return self._real_repository.break_lock()
 
1744
        path = self.controldir._path_for_remote_call(self._client)
 
1745
        try:
 
1746
            response = self._call("Repository.break_lock", path)
 
1747
        except errors.UnknownSmartMethod:
 
1748
            self._ensure_real()
 
1749
            return self._real_repository.break_lock()
 
1750
        if response != ('ok',):
 
1751
            raise errors.UnexpectedSmartServerResponse(response)
1183
1752
 
1184
1753
    def _get_tarball(self, compression):
1185
1754
        """Return a TemporaryFile containing a repository tarball.
1187
1756
        Returns None if the server does not support sending tarballs.
1188
1757
        """
1189
1758
        import tempfile
1190
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
1759
        path = self.controldir._path_for_remote_call(self._client)
1191
1760
        try:
1192
1761
            response, protocol = self._call_expecting_body(
1193
1762
                'Repository.tarball', path, compression)
1203
1772
            return t
1204
1773
        raise errors.UnexpectedSmartServerResponse(response)
1205
1774
 
 
1775
    @needs_read_lock
1206
1776
    def sprout(self, to_bzrdir, revision_id=None):
1207
 
        # TODO: Option to control what format is created?
1208
 
        self._ensure_real()
1209
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1210
 
                                                             shared=False)
 
1777
        """Create a descendent repository for new development.
 
1778
 
 
1779
        Unlike clone, this does not copy the settings of the repository.
 
1780
        """
 
1781
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1211
1782
        dest_repo.fetch(self, revision_id=revision_id)
1212
1783
        return dest_repo
1213
1784
 
 
1785
    def _create_sprouting_repo(self, a_controldir, shared):
 
1786
        if not isinstance(a_controldir._format, self.controldir._format.__class__):
 
1787
            # use target default format.
 
1788
            dest_repo = a_controldir.create_repository()
 
1789
        else:
 
1790
            # Most control formats need the repository to be specifically
 
1791
            # created, but on some old all-in-one formats it's not needed
 
1792
            try:
 
1793
                dest_repo = self._format.initialize(a_controldir, shared=shared)
 
1794
            except errors.UninitializableFormat:
 
1795
                dest_repo = a_controldir.open_repository()
 
1796
        return dest_repo
 
1797
 
1214
1798
    ### These methods are just thin shims to the VFS object for now.
1215
1799
 
 
1800
    @needs_read_lock
1216
1801
    def revision_tree(self, revision_id):
1217
 
        self._ensure_real()
1218
 
        return self._real_repository.revision_tree(revision_id)
 
1802
        revision_id = _mod_revision.ensure_null(revision_id)
 
1803
        if revision_id == _mod_revision.NULL_REVISION:
 
1804
            return InventoryRevisionTree(self,
 
1805
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1806
        else:
 
1807
            return list(self.revision_trees([revision_id]))[0]
1219
1808
 
1220
1809
    def get_serializer_format(self):
1221
 
        self._ensure_real()
1222
 
        return self._real_repository.get_serializer_format()
 
1810
        path = self.controldir._path_for_remote_call(self._client)
 
1811
        try:
 
1812
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1813
                path)
 
1814
        except errors.UnknownSmartMethod:
 
1815
            self._ensure_real()
 
1816
            return self._real_repository.get_serializer_format()
 
1817
        if response[0] != 'ok':
 
1818
            raise errors.UnexpectedSmartServerResponse(response)
 
1819
        return response[1]
1223
1820
 
1224
1821
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1225
1822
                           timezone=None, committer=None, revprops=None,
1226
 
                           revision_id=None):
1227
 
        # FIXME: It ought to be possible to call this without immediately
1228
 
        # triggering _ensure_real.  For now it's the easiest thing to do.
1229
 
        self._ensure_real()
1230
 
        real_repo = self._real_repository
1231
 
        builder = real_repo.get_commit_builder(branch, parents,
1232
 
                config, timestamp=timestamp, timezone=timezone,
1233
 
                committer=committer, revprops=revprops, revision_id=revision_id)
1234
 
        return builder
 
1823
                           revision_id=None, lossy=False):
 
1824
        """Obtain a CommitBuilder for this repository.
 
1825
 
 
1826
        :param branch: Branch to commit to.
 
1827
        :param parents: Revision ids of the parents of the new revision.
 
1828
        :param config: Configuration to use.
 
1829
        :param timestamp: Optional timestamp recorded for commit.
 
1830
        :param timezone: Optional timezone for timestamp.
 
1831
        :param committer: Optional committer to set for commit.
 
1832
        :param revprops: Optional dictionary of revision properties.
 
1833
        :param revision_id: Optional revision id.
 
1834
        :param lossy: Whether to discard data that can not be natively
 
1835
            represented, when pushing to a foreign VCS
 
1836
        """
 
1837
        if self._fallback_repositories and not self._format.supports_chks:
 
1838
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1839
                " in pre-2a formats. See "
 
1840
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1841
        if self._format.rich_root_data:
 
1842
            commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
 
1843
        else:
 
1844
            commit_builder_kls = vf_repository.VersionedFileCommitBuilder
 
1845
        result = commit_builder_kls(self, parents, config,
 
1846
            timestamp, timezone, committer, revprops, revision_id,
 
1847
            lossy)
 
1848
        self.start_write_group()
 
1849
        return result
1235
1850
 
1236
1851
    def add_fallback_repository(self, repository):
1237
1852
        """Add a repository to use for looking up data not held locally.
1244
1859
        # We need to accumulate additional repositories here, to pass them in
1245
1860
        # on various RPC's.
1246
1861
        #
 
1862
        # Make the check before we lock: this raises an exception.
 
1863
        self._check_fallback_repository(repository)
1247
1864
        if self.is_locked():
1248
1865
            # We will call fallback.unlock() when we transition to the unlocked
1249
1866
            # state, so always add a lock here. If a caller passes us a locked
1250
1867
            # repository, they are responsible for unlocking it later.
1251
1868
            repository.lock_read()
1252
 
        self._check_fallback_repository(repository)
1253
1869
        self._fallback_repositories.append(repository)
1254
1870
        # If self._real_repository was parameterised already (e.g. because a
1255
1871
        # _real_branch had its get_stacked_on_url method called), then the
1281
1897
            delta, new_revision_id, parents, basis_inv=basis_inv,
1282
1898
            propagate_caches=propagate_caches)
1283
1899
 
1284
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
1285
 
        self._ensure_real()
1286
 
        return self._real_repository.add_revision(
1287
 
            rev_id, rev, inv=inv, config=config)
 
1900
    def add_revision(self, revision_id, rev, inv=None):
 
1901
        _mod_revision.check_not_reserved_id(revision_id)
 
1902
        key = (revision_id,)
 
1903
        # check inventory present
 
1904
        if not self.inventories.get_parent_map([key]):
 
1905
            if inv is None:
 
1906
                raise errors.WeaveRevisionNotPresent(revision_id,
 
1907
                                                     self.inventories)
 
1908
            else:
 
1909
                # yes, this is not suitable for adding with ghosts.
 
1910
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
1911
                                                        rev.parent_ids)
 
1912
        else:
 
1913
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
1914
        self._add_revision(rev)
 
1915
 
 
1916
    def _add_revision(self, rev):
 
1917
        if self._real_repository is not None:
 
1918
            return self._real_repository._add_revision(rev)
 
1919
        text = self._serializer.write_revision_to_string(rev)
 
1920
        key = (rev.revision_id,)
 
1921
        parents = tuple((parent,) for parent in rev.parent_ids)
 
1922
        self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
 
1923
            [('revisions', [FulltextContentFactory(key, parents, None, text)])],
 
1924
            self._format, self._write_group_tokens)
1288
1925
 
1289
1926
    @needs_read_lock
1290
1927
    def get_inventory(self, revision_id):
 
1928
        return list(self.iter_inventories([revision_id]))[0]
 
1929
 
 
1930
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1931
        if ordering is None:
 
1932
            ordering = 'unordered'
 
1933
        path = self.controldir._path_for_remote_call(self._client)
 
1934
        body = "\n".join(revision_ids)
 
1935
        response_tuple, response_handler = (
 
1936
            self._call_with_body_bytes_expecting_body(
 
1937
                "VersionedFileRepository.get_inventories",
 
1938
                (path, ordering), body))
 
1939
        if response_tuple[0] != "ok":
 
1940
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1941
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1942
        byte_stream = response_handler.read_streamed_body()
 
1943
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1944
        if decoded is None:
 
1945
            # no results whatsoever
 
1946
            return
 
1947
        src_format, stream = decoded
 
1948
        if src_format.network_name() != self._format.network_name():
 
1949
            raise AssertionError(
 
1950
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1951
                src_format.network_name(), self._format.network_name()))
 
1952
        # ignore the src format, it's not really relevant
 
1953
        prev_inv = Inventory(root_id=None,
 
1954
            revision_id=_mod_revision.NULL_REVISION)
 
1955
        # there should be just one substream, with inventory deltas
 
1956
        substream_kind, substream = next(stream)
 
1957
        if substream_kind != "inventory-deltas":
 
1958
            raise AssertionError(
 
1959
                 "Unexpected stream %r received" % substream_kind)
 
1960
        for record in substream:
 
1961
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1962
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1963
            if parent_id != prev_inv.revision_id:
 
1964
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1965
                    prev_inv.revision_id))
 
1966
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1967
            yield inv, inv.revision_id
 
1968
            prev_inv = inv
 
1969
 
 
1970
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
1291
1971
        self._ensure_real()
1292
 
        return self._real_repository.get_inventory(revision_id)
 
1972
        return self._real_repository._iter_inventories(revision_ids, ordering)
1293
1973
 
1294
1974
    def iter_inventories(self, revision_ids, ordering=None):
1295
 
        self._ensure_real()
1296
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1975
        """Get many inventories by revision_ids.
 
1976
 
 
1977
        This will buffer some or all of the texts used in constructing the
 
1978
        inventories in memory, but will only parse a single inventory at a
 
1979
        time.
 
1980
 
 
1981
        :param revision_ids: The expected revision ids of the inventories.
 
1982
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1983
            specified, the order of revision_ids will be preserved (by
 
1984
            buffering if necessary).
 
1985
        :return: An iterator of inventories.
 
1986
        """
 
1987
        if ((None in revision_ids)
 
1988
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1989
            raise ValueError('cannot get null revision inventory')
 
1990
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1991
            if inv is None:
 
1992
                raise errors.NoSuchRevision(self, revid)
 
1993
            yield inv
 
1994
 
 
1995
    def _iter_inventories(self, revision_ids, ordering=None):
 
1996
        if len(revision_ids) == 0:
 
1997
            return
 
1998
        missing = set(revision_ids)
 
1999
        if ordering is None:
 
2000
            order_as_requested = True
 
2001
            invs = {}
 
2002
            order = list(revision_ids)
 
2003
            order.reverse()
 
2004
            next_revid = order.pop()
 
2005
        else:
 
2006
            order_as_requested = False
 
2007
            if ordering != 'unordered' and self._fallback_repositories:
 
2008
                raise ValueError('unsupported ordering %r' % ordering)
 
2009
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
2010
            fallback._iter_inventories for fallback in
 
2011
            self._fallback_repositories]
 
2012
        try:
 
2013
            for iter_inv in iter_inv_fns:
 
2014
                request = [revid for revid in revision_ids if revid in missing]
 
2015
                for inv, revid in iter_inv(request, ordering):
 
2016
                    if inv is None:
 
2017
                        continue
 
2018
                    missing.remove(inv.revision_id)
 
2019
                    if ordering != 'unordered':
 
2020
                        invs[revid] = inv
 
2021
                    else:
 
2022
                        yield inv, revid
 
2023
                if order_as_requested:
 
2024
                    # Yield as many results as we can while preserving order.
 
2025
                    while next_revid in invs:
 
2026
                        inv = invs.pop(next_revid)
 
2027
                        yield inv, inv.revision_id
 
2028
                        try:
 
2029
                            next_revid = order.pop()
 
2030
                        except IndexError:
 
2031
                            # We still want to fully consume the stream, just
 
2032
                            # in case it is not actually finished at this point
 
2033
                            next_revid = None
 
2034
                            break
 
2035
        except errors.UnknownSmartMethod:
 
2036
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
2037
                yield inv, revid
 
2038
            return
 
2039
        # Report missing
 
2040
        if order_as_requested:
 
2041
            if next_revid is not None:
 
2042
                yield None, next_revid
 
2043
            while order:
 
2044
                revid = order.pop()
 
2045
                yield invs.get(revid), revid
 
2046
        else:
 
2047
            while missing:
 
2048
                yield None, missing.pop()
1297
2049
 
1298
2050
    @needs_read_lock
1299
2051
    def get_revision(self, revision_id):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.get_revision(revision_id)
 
2052
        return self.get_revisions([revision_id])[0]
1302
2053
 
1303
2054
    def get_transaction(self):
1304
2055
        self._ensure_real()
1305
2056
        return self._real_repository.get_transaction()
1306
2057
 
1307
2058
    @needs_read_lock
1308
 
    def clone(self, a_bzrdir, revision_id=None):
1309
 
        self._ensure_real()
1310
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
2059
    def clone(self, a_controldir, revision_id=None):
 
2060
        dest_repo = self._create_sprouting_repo(
 
2061
            a_controldir, shared=self.is_shared())
 
2062
        self.copy_content_into(dest_repo, revision_id)
 
2063
        return dest_repo
1311
2064
 
1312
2065
    def make_working_trees(self):
1313
2066
        """See Repository.make_working_trees"""
1314
 
        self._ensure_real()
1315
 
        return self._real_repository.make_working_trees()
 
2067
        path = self.controldir._path_for_remote_call(self._client)
 
2068
        try:
 
2069
            response = self._call('Repository.make_working_trees', path)
 
2070
        except errors.UnknownSmartMethod:
 
2071
            self._ensure_real()
 
2072
            return self._real_repository.make_working_trees()
 
2073
        if response[0] not in ('yes', 'no'):
 
2074
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2075
        return response[0] == 'yes'
1316
2076
 
1317
2077
    def refresh_data(self):
1318
2078
        """Re-read any data needed to synchronise with disk.
1320
2080
        This method is intended to be called after another repository instance
1321
2081
        (such as one used by a smart server) has inserted data into the
1322
2082
        repository. On all repositories this will work outside of write groups.
1323
 
        Some repository formats (pack and newer for bzrlib native formats)
 
2083
        Some repository formats (pack and newer for breezy native formats)
1324
2084
        support refresh_data inside write groups. If called inside a write
1325
2085
        group on a repository that does not support refreshing in a write group
1326
2086
        IsInWriteGroupError will be raised.
1327
2087
        """
1328
2088
        if self._real_repository is not None:
1329
2089
            self._real_repository.refresh_data()
 
2090
        # Refresh the parents cache for this object
 
2091
        self._unstacked_provider.disable_cache()
 
2092
        self._unstacked_provider.enable_cache()
1330
2093
 
1331
2094
    def revision_ids_to_search_result(self, result_set):
1332
2095
        """Convert a set of revision ids to a graph SearchResult."""
1333
2096
        result_parents = set()
1334
 
        for parents in self.get_graph().get_parent_map(
1335
 
            result_set).itervalues():
 
2097
        for parents in viewvalues(self.get_graph().get_parent_map(result_set)):
1336
2098
            result_parents.update(parents)
1337
2099
        included_keys = result_set.intersection(result_parents)
1338
2100
        start_keys = result_set.difference(included_keys)
1339
2101
        exclude_keys = result_parents.difference(result_set)
1340
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2102
        result = vf_search.SearchResult(start_keys, exclude_keys,
1341
2103
            len(result_set), result_set)
1342
2104
        return result
1343
2105
 
1344
2106
    @needs_read_lock
1345
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
2107
    def search_missing_revision_ids(self, other,
 
2108
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2109
            limit=None):
1346
2110
        """Return the revision ids that other has that this does not.
1347
2111
 
1348
2112
        These are returned in topological order.
1349
2113
 
1350
2114
        revision_id: only return revision ids included by revision_id.
1351
2115
        """
1352
 
        return repository.InterRepository.get(
1353
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
2116
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
2117
        return inter_repo.search_missing_revision_ids(
 
2118
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
2119
            if_present_ids=if_present_ids, limit=limit)
1354
2120
 
1355
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2121
    def fetch(self, source, revision_id=None, find_ghosts=False,
1356
2122
            fetch_spec=None):
1357
2123
        # No base implementation to use as RemoteRepository is not a subclass
1358
2124
        # of Repository; so this is a copy of Repository.fetch().
1369
2135
            # check that last_revision is in 'from' and then return a
1370
2136
            # no-operation.
1371
2137
            if (revision_id is not None and
1372
 
                not revision.is_null(revision_id)):
 
2138
                not _mod_revision.is_null(revision_id)):
1373
2139
                self.get_revision(revision_id)
1374
2140
            return 0, []
1375
2141
        # if there is no specific appropriate InterRepository, this will get
1376
2142
        # the InterRepository base class, which raises an
1377
2143
        # IncompatibleRepositories when asked to fetch.
1378
 
        inter = repository.InterRepository.get(source, self)
1379
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
2144
        inter = _mod_repository.InterRepository.get(source, self)
 
2145
        if (fetch_spec is not None and
 
2146
            not getattr(inter, "supports_fetch_spec", False)):
 
2147
            raise errors.UnsupportedOperation(
 
2148
                "fetch_spec not supported for %r" % inter)
 
2149
        return inter.fetch(revision_id=revision_id,
1380
2150
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1381
2151
 
1382
2152
    def create_bundle(self, target, base, fileobj, format=None):
1383
2153
        self._ensure_real()
1384
2154
        self._real_repository.create_bundle(target, base, fileobj, format)
1385
2155
 
1386
 
    @needs_read_lock
1387
 
    def get_ancestry(self, revision_id, topo_sorted=True):
1388
 
        self._ensure_real()
1389
 
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1390
 
 
1391
2156
    def fileids_altered_by_revision_ids(self, revision_ids):
1392
2157
        self._ensure_real()
1393
2158
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1397
2162
        return self._real_repository._get_versioned_file_checker(
1398
2163
            revisions, revision_versions_cache)
1399
2164
 
 
2165
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2166
        path = self.controldir._path_for_remote_call(self._client)
 
2167
        lines = []
 
2168
        identifiers = []
 
2169
        for (file_id, revid, identifier) in desired_files:
 
2170
            lines.append("%s\0%s" % (
 
2171
                osutils.safe_file_id(file_id),
 
2172
                osutils.safe_revision_id(revid)))
 
2173
            identifiers.append(identifier)
 
2174
        (response_tuple, response_handler) = (
 
2175
            self._call_with_body_bytes_expecting_body(
 
2176
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2177
        if response_tuple != ('ok', ):
 
2178
            response_handler.cancel_read_body()
 
2179
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2180
        byte_stream = response_handler.read_streamed_body()
 
2181
        def decompress_stream(start, byte_stream, unused):
 
2182
            decompressor = zlib.decompressobj()
 
2183
            yield decompressor.decompress(start)
 
2184
            while decompressor.unused_data == "":
 
2185
                try:
 
2186
                    data = next(byte_stream)
 
2187
                except StopIteration:
 
2188
                    break
 
2189
                yield decompressor.decompress(data)
 
2190
            yield decompressor.flush()
 
2191
            unused.append(decompressor.unused_data)
 
2192
        unused = ""
 
2193
        while True:
 
2194
            while not "\n" in unused:
 
2195
                unused += next(byte_stream)
 
2196
            header, rest = unused.split("\n", 1)
 
2197
            args = header.split("\0")
 
2198
            if args[0] == "absent":
 
2199
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2200
                unused = rest
 
2201
                continue
 
2202
            elif args[0] == "ok":
 
2203
                idx = int(args[1])
 
2204
            else:
 
2205
                raise errors.UnexpectedSmartServerResponse(args)
 
2206
            unused_chunks = []
 
2207
            yield (identifiers[idx],
 
2208
                decompress_stream(rest, byte_stream, unused_chunks))
 
2209
            unused = "".join(unused_chunks)
 
2210
 
1400
2211
    def iter_files_bytes(self, desired_files):
1401
2212
        """See Repository.iter_file_bytes.
1402
2213
        """
1403
 
        self._ensure_real()
1404
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2214
        try:
 
2215
            absent = {}
 
2216
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2217
                    desired_files, absent):
 
2218
                yield identifier, bytes_iterator
 
2219
            for fallback in self._fallback_repositories:
 
2220
                if not absent:
 
2221
                    break
 
2222
                desired_files = [(key[0], key[1], identifier)
 
2223
                    for identifier, key in viewitems(absent)]
 
2224
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2225
                    del absent[identifier]
 
2226
                    yield identifier, bytes_iterator
 
2227
            if absent:
 
2228
                # There may be more missing items, but raise an exception
 
2229
                # for just one.
 
2230
                missing_identifier = next(iter(absent))
 
2231
                missing_key = absent[missing_identifier]
 
2232
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2233
                    file_id=missing_key[0])
 
2234
        except errors.UnknownSmartMethod:
 
2235
            self._ensure_real()
 
2236
            for (identifier, bytes_iterator) in (
 
2237
                self._real_repository.iter_files_bytes(desired_files)):
 
2238
                yield identifier, bytes_iterator
 
2239
 
 
2240
    def get_cached_parent_map(self, revision_ids):
 
2241
        """See breezy.CachingParentsProvider.get_cached_parent_map"""
 
2242
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1405
2243
 
1406
2244
    def get_parent_map(self, revision_ids):
1407
 
        """See bzrlib.Graph.get_parent_map()."""
 
2245
        """See breezy.Graph.get_parent_map()."""
1408
2246
        return self._make_parents_provider().get_parent_map(revision_ids)
1409
2247
 
1410
2248
    def _get_parent_map_rpc(self, keys):
1429
2267
            # There is one other "bug" which is that ghosts in
1430
2268
            # get_revision_graph() are not returned at all. But we won't worry
1431
2269
            # about that for now.
1432
 
            for node_id, parent_ids in rg.iteritems():
 
2270
            for node_id, parent_ids in viewitems(rg):
1433
2271
                if parent_ids == ():
1434
2272
                    rg[node_id] = (NULL_REVISION,)
1435
2273
            rg[NULL_REVISION] = ()
1466
2304
        if parents_map is None:
1467
2305
            # Repository is not locked, so there's no cache.
1468
2306
            parents_map = {}
1469
 
        # start_set is all the keys in the cache
1470
 
        start_set = set(parents_map)
1471
 
        # result set is all the references to keys in the cache
1472
 
        result_parents = set()
1473
 
        for parents in parents_map.itervalues():
1474
 
            result_parents.update(parents)
1475
 
        stop_keys = result_parents.difference(start_set)
1476
 
        # We don't need to send ghosts back to the server as a position to
1477
 
        # stop either.
1478
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1479
 
        key_count = len(parents_map)
1480
 
        if (NULL_REVISION in result_parents
1481
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1482
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1483
 
            # in our cache of "missing" keys we need to increment our key count
1484
 
            # by 1, because the reconsitituted SearchResult on the server will
1485
 
            # still consider NULL_REVISION to be an included key.
1486
 
            key_count += 1
1487
 
        included_keys = start_set.intersection(result_parents)
1488
 
        start_set.difference_update(included_keys)
 
2307
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2308
            (start_set, stop_keys,
 
2309
             key_count) = vf_search.search_result_from_parent_map(
 
2310
                parents_map, self._unstacked_provider.missing_keys)
 
2311
        else:
 
2312
            (start_set, stop_keys,
 
2313
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2314
                parents_map, self._unstacked_provider.missing_keys,
 
2315
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1489
2316
        recipe = ('manual', start_set, stop_keys, key_count)
1490
2317
        body = self._serialise_search_recipe(recipe)
1491
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
2318
        path = self.controldir._path_for_remote_call(self._client)
1492
2319
        for key in keys:
1493
 
            if type(key) is not str:
 
2320
            if not isinstance(key, str):
1494
2321
                raise ValueError(
1495
2322
                    "key %r not a plain string" % (key,))
1496
2323
        verb = 'Repository.get_parent_map'
1540
2367
 
1541
2368
    @needs_read_lock
1542
2369
    def get_signature_text(self, revision_id):
1543
 
        self._ensure_real()
1544
 
        return self._real_repository.get_signature_text(revision_id)
 
2370
        path = self.controldir._path_for_remote_call(self._client)
 
2371
        try:
 
2372
            response_tuple, response_handler = self._call_expecting_body(
 
2373
                'Repository.get_revision_signature_text', path, revision_id)
 
2374
        except errors.UnknownSmartMethod:
 
2375
            self._ensure_real()
 
2376
            return self._real_repository.get_signature_text(revision_id)
 
2377
        except errors.NoSuchRevision as err:
 
2378
            for fallback in self._fallback_repositories:
 
2379
                try:
 
2380
                    return fallback.get_signature_text(revision_id)
 
2381
                except errors.NoSuchRevision:
 
2382
                    pass
 
2383
            raise err
 
2384
        else:
 
2385
            if response_tuple[0] != 'ok':
 
2386
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2387
            return response_handler.read_body_bytes()
1545
2388
 
1546
2389
    @needs_read_lock
1547
2390
    def _get_inventory_xml(self, revision_id):
 
2391
        # This call is used by older working tree formats,
 
2392
        # which stored a serialized basis inventory.
1548
2393
        self._ensure_real()
1549
2394
        return self._real_repository._get_inventory_xml(revision_id)
1550
2395
 
 
2396
    @needs_write_lock
1551
2397
    def reconcile(self, other=None, thorough=False):
1552
 
        self._ensure_real()
1553
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2398
        from .reconcile import RepoReconciler
 
2399
        path = self.controldir._path_for_remote_call(self._client)
 
2400
        try:
 
2401
            response, handler = self._call_expecting_body(
 
2402
                'Repository.reconcile', path, self._lock_token)
 
2403
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2404
            self._ensure_real()
 
2405
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2406
        if response != ('ok', ):
 
2407
            raise errors.UnexpectedSmartServerResponse(response)
 
2408
        body = handler.read_body_bytes()
 
2409
        result = RepoReconciler(self)
 
2410
        for line in body.split('\n'):
 
2411
            if not line:
 
2412
                continue
 
2413
            key, val_text = line.split(':')
 
2414
            if key == "garbage_inventories":
 
2415
                result.garbage_inventories = int(val_text)
 
2416
            elif key == "inconsistent_parents":
 
2417
                result.inconsistent_parents = int(val_text)
 
2418
            else:
 
2419
                mutter("unknown reconcile key %r" % key)
 
2420
        return result
1554
2421
 
1555
2422
    def all_revision_ids(self):
1556
 
        self._ensure_real()
1557
 
        return self._real_repository.all_revision_ids()
 
2423
        path = self.controldir._path_for_remote_call(self._client)
 
2424
        try:
 
2425
            response_tuple, response_handler = self._call_expecting_body(
 
2426
                "Repository.all_revision_ids", path)
 
2427
        except errors.UnknownSmartMethod:
 
2428
            self._ensure_real()
 
2429
            return self._real_repository.all_revision_ids()
 
2430
        if response_tuple != ("ok", ):
 
2431
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2432
        revids = set(response_handler.read_body_bytes().splitlines())
 
2433
        for fallback in self._fallback_repositories:
 
2434
            revids.update(set(fallback.all_revision_ids()))
 
2435
        return list(revids)
 
2436
 
 
2437
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2438
        """Return Tree for a revision on this branch with only some files.
 
2439
 
 
2440
        :param revision_ids: a sequence of revision-ids;
 
2441
          a revision-id may not be None or 'null:'
 
2442
        :param file_ids: if not None, the result is filtered
 
2443
          so that only those file-ids, their parents and their
 
2444
          children are included.
 
2445
        """
 
2446
        inventories = self.iter_inventories(revision_ids)
 
2447
        for inv in inventories:
 
2448
            # Should we introduce a FilteredRevisionTree class rather
 
2449
            # than pre-filter the inventory here?
 
2450
            filtered_inv = inv.filter(file_ids)
 
2451
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1558
2452
 
1559
2453
    @needs_read_lock
1560
2454
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1561
 
        self._ensure_real()
1562
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1563
 
            specific_fileids=specific_fileids)
 
2455
        medium = self._client._medium
 
2456
        if medium._is_remote_before((1, 2)):
 
2457
            self._ensure_real()
 
2458
            for delta in self._real_repository.get_deltas_for_revisions(
 
2459
                    revisions, specific_fileids):
 
2460
                yield delta
 
2461
            return
 
2462
        # Get the revision-ids of interest
 
2463
        required_trees = set()
 
2464
        for revision in revisions:
 
2465
            required_trees.add(revision.revision_id)
 
2466
            required_trees.update(revision.parent_ids[:1])
 
2467
 
 
2468
        # Get the matching filtered trees. Note that it's more
 
2469
        # efficient to pass filtered trees to changes_from() rather
 
2470
        # than doing the filtering afterwards. changes_from() could
 
2471
        # arguably do the filtering itself but it's path-based, not
 
2472
        # file-id based, so filtering before or afterwards is
 
2473
        # currently easier.
 
2474
        if specific_fileids is None:
 
2475
            trees = dict((t.get_revision_id(), t) for
 
2476
                t in self.revision_trees(required_trees))
 
2477
        else:
 
2478
            trees = dict((t.get_revision_id(), t) for
 
2479
                t in self._filtered_revision_trees(required_trees,
 
2480
                specific_fileids))
 
2481
 
 
2482
        # Calculate the deltas
 
2483
        for revision in revisions:
 
2484
            if not revision.parent_ids:
 
2485
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2486
            else:
 
2487
                old_tree = trees[revision.parent_ids[0]]
 
2488
            yield trees[revision.revision_id].changes_from(old_tree)
1564
2489
 
1565
2490
    @needs_read_lock
1566
2491
    def get_revision_delta(self, revision_id, specific_fileids=None):
1567
 
        self._ensure_real()
1568
 
        return self._real_repository.get_revision_delta(revision_id,
1569
 
            specific_fileids=specific_fileids)
 
2492
        r = self.get_revision(revision_id)
 
2493
        return list(self.get_deltas_for_revisions([r],
 
2494
            specific_fileids=specific_fileids))[0]
1570
2495
 
1571
2496
    @needs_read_lock
1572
2497
    def revision_trees(self, revision_ids):
1573
 
        self._ensure_real()
1574
 
        return self._real_repository.revision_trees(revision_ids)
 
2498
        inventories = self.iter_inventories(revision_ids)
 
2499
        for inv in inventories:
 
2500
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1575
2501
 
1576
2502
    @needs_read_lock
1577
2503
    def get_revision_reconcile(self, revision_id):
1585
2511
            callback_refs=callback_refs, check_repo=check_repo)
1586
2512
 
1587
2513
    def copy_content_into(self, destination, revision_id=None):
1588
 
        self._ensure_real()
1589
 
        return self._real_repository.copy_content_into(
1590
 
            destination, revision_id=revision_id)
 
2514
        """Make a complete copy of the content in self into destination.
 
2515
 
 
2516
        This is a destructive operation! Do not use it on existing
 
2517
        repositories.
 
2518
        """
 
2519
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2520
        return interrepo.copy_content(revision_id)
1591
2521
 
1592
2522
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1593
2523
        # get a tarball of the remote repository, and copy from that into the
1594
2524
        # destination
1595
 
        from bzrlib import osutils
1596
2525
        import tarfile
1597
2526
        # TODO: Maybe a progress bar while streaming the tarball?
1598
 
        note("Copying repository content as tarball...")
 
2527
        note(gettext("Copying repository content as tarball..."))
1599
2528
        tar_file = self._get_tarball('bz2')
1600
2529
        if tar_file is None:
1601
2530
            return None
1606
2535
            tmpdir = osutils.mkdtemp()
1607
2536
            try:
1608
2537
                _extract_tar(tar, tmpdir)
1609
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2538
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1610
2539
                tmp_repo = tmp_bzrdir.open_repository()
1611
2540
                tmp_repo.copy_content_into(destination, revision_id)
1612
2541
            finally:
1630
2559
    @needs_write_lock
1631
2560
    def pack(self, hint=None, clean_obsolete_packs=False):
1632
2561
        """Compress the data within the repository.
1633
 
 
1634
 
        This is not currently implemented within the smart server.
1635
2562
        """
1636
 
        self._ensure_real()
1637
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2563
        if hint is None:
 
2564
            body = ""
 
2565
        else:
 
2566
            body = "".join([l+"\n" for l in hint])
 
2567
        path = self.controldir._path_for_remote_call(self._client)
 
2568
        try:
 
2569
            response, handler = self._call_with_body_bytes_expecting_body(
 
2570
                'Repository.pack', (path, self._lock_token,
 
2571
                    str(clean_obsolete_packs)), body)
 
2572
        except errors.UnknownSmartMethod:
 
2573
            self._ensure_real()
 
2574
            return self._real_repository.pack(hint=hint,
 
2575
                clean_obsolete_packs=clean_obsolete_packs)
 
2576
        handler.cancel_read_body()
 
2577
        if response != ('ok', ):
 
2578
            raise errors.UnexpectedSmartServerResponse(response)
1638
2579
 
1639
2580
    @property
1640
2581
    def revisions(self):
1641
2582
        """Decorate the real repository for now.
1642
2583
 
1643
 
        In the short term this should become a real object to intercept graph
1644
 
        lookups.
1645
 
 
1646
2584
        In the long term a full blown network facility is needed.
1647
2585
        """
1648
2586
        self._ensure_real()
1653
2591
            new_value_str = "True"
1654
2592
        else:
1655
2593
            new_value_str = "False"
1656
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
2594
        path = self.controldir._path_for_remote_call(self._client)
1657
2595
        try:
1658
2596
            response = self._call(
1659
2597
                'Repository.set_make_working_trees', path, new_value_str)
1676
2614
 
1677
2615
    @needs_write_lock
1678
2616
    def sign_revision(self, revision_id, gpg_strategy):
1679
 
        self._ensure_real()
1680
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2617
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2618
        plaintext = testament.as_short_text()
 
2619
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1681
2620
 
1682
2621
    @property
1683
2622
    def texts(self):
1689
2628
        self._ensure_real()
1690
2629
        return self._real_repository.texts
1691
2630
 
 
2631
    def _iter_revisions_rpc(self, revision_ids):
 
2632
        body = "\n".join(revision_ids)
 
2633
        path = self.controldir._path_for_remote_call(self._client)
 
2634
        response_tuple, response_handler = (
 
2635
            self._call_with_body_bytes_expecting_body(
 
2636
            "Repository.iter_revisions", (path, ), body))
 
2637
        if response_tuple[0] != "ok":
 
2638
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2639
        serializer_format = response_tuple[1]
 
2640
        serializer = serializer_format_registry.get(serializer_format)
 
2641
        byte_stream = response_handler.read_streamed_body()
 
2642
        decompressor = zlib.decompressobj()
 
2643
        chunks = []
 
2644
        for bytes in byte_stream:
 
2645
            chunks.append(decompressor.decompress(bytes))
 
2646
            if decompressor.unused_data != "":
 
2647
                chunks.append(decompressor.flush())
 
2648
                yield serializer.read_revision_from_string("".join(chunks))
 
2649
                unused = decompressor.unused_data
 
2650
                decompressor = zlib.decompressobj()
 
2651
                chunks = [decompressor.decompress(unused)]
 
2652
        chunks.append(decompressor.flush())
 
2653
        text = "".join(chunks)
 
2654
        if text != "":
 
2655
            yield serializer.read_revision_from_string("".join(chunks))
 
2656
 
1692
2657
    @needs_read_lock
1693
2658
    def get_revisions(self, revision_ids):
1694
 
        self._ensure_real()
1695
 
        return self._real_repository.get_revisions(revision_ids)
 
2659
        if revision_ids is None:
 
2660
            revision_ids = self.all_revision_ids()
 
2661
        else:
 
2662
            for rev_id in revision_ids:
 
2663
                if not rev_id or not isinstance(rev_id, basestring):
 
2664
                    raise errors.InvalidRevisionId(
 
2665
                        revision_id=rev_id, branch=self)
 
2666
        try:
 
2667
            missing = set(revision_ids)
 
2668
            revs = {}
 
2669
            for rev in self._iter_revisions_rpc(revision_ids):
 
2670
                missing.remove(rev.revision_id)
 
2671
                revs[rev.revision_id] = rev
 
2672
        except errors.UnknownSmartMethod:
 
2673
            self._ensure_real()
 
2674
            return self._real_repository.get_revisions(revision_ids)
 
2675
        for fallback in self._fallback_repositories:
 
2676
            if not missing:
 
2677
                break
 
2678
            for revid in list(missing):
 
2679
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2680
                # public method on Repository that could be used to query
 
2681
                # for revision objects *without* failing completely if one
 
2682
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2683
                # but unfortunately that's private and not provided by
 
2684
                # all repository implementations.
 
2685
                try:
 
2686
                    revs[revid] = fallback.get_revision(revid)
 
2687
                except errors.NoSuchRevision:
 
2688
                    pass
 
2689
                else:
 
2690
                    missing.remove(revid)
 
2691
        if missing:
 
2692
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2693
        return [revs[revid] for revid in revision_ids]
1696
2694
 
1697
2695
    def supports_rich_root(self):
1698
2696
        return self._format.rich_root_data
1699
2697
 
1700
 
    def iter_reverse_revision_history(self, revision_id):
1701
 
        self._ensure_real()
1702
 
        return self._real_repository.iter_reverse_revision_history(revision_id)
1703
 
 
1704
2698
    @property
1705
2699
    def _serializer(self):
1706
2700
        return self._format._serializer
1707
2701
 
 
2702
    @needs_write_lock
1708
2703
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1709
 
        self._ensure_real()
1710
 
        return self._real_repository.store_revision_signature(
1711
 
            gpg_strategy, plaintext, revision_id)
 
2704
        signature = gpg_strategy.sign(plaintext)
 
2705
        self.add_signature_text(revision_id, signature)
1712
2706
 
1713
2707
    def add_signature_text(self, revision_id, signature):
1714
 
        self._ensure_real()
1715
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2708
        if self._real_repository:
 
2709
            # If there is a real repository the write group will
 
2710
            # be in the real repository as well, so use that:
 
2711
            self._ensure_real()
 
2712
            return self._real_repository.add_signature_text(
 
2713
                revision_id, signature)
 
2714
        path = self.controldir._path_for_remote_call(self._client)
 
2715
        response, handler = self._call_with_body_bytes_expecting_body(
 
2716
            'Repository.add_signature_text', (path, self._lock_token,
 
2717
                revision_id) + tuple(self._write_group_tokens), signature)
 
2718
        handler.cancel_read_body()
 
2719
        self.refresh_data()
 
2720
        if response[0] != 'ok':
 
2721
            raise errors.UnexpectedSmartServerResponse(response)
 
2722
        self._write_group_tokens = response[1:]
1716
2723
 
1717
2724
    def has_signature_for_revision_id(self, revision_id):
1718
 
        self._ensure_real()
1719
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2725
        path = self.controldir._path_for_remote_call(self._client)
 
2726
        try:
 
2727
            response = self._call('Repository.has_signature_for_revision_id',
 
2728
                path, revision_id)
 
2729
        except errors.UnknownSmartMethod:
 
2730
            self._ensure_real()
 
2731
            return self._real_repository.has_signature_for_revision_id(
 
2732
                revision_id)
 
2733
        if response[0] not in ('yes', 'no'):
 
2734
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2735
        if response[0] == 'yes':
 
2736
            return True
 
2737
        for fallback in self._fallback_repositories:
 
2738
            if fallback.has_signature_for_revision_id(revision_id):
 
2739
                return True
 
2740
        return False
 
2741
 
 
2742
    @needs_read_lock
 
2743
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2744
        if not self.has_signature_for_revision_id(revision_id):
 
2745
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2746
        signature = self.get_signature_text(revision_id)
 
2747
 
 
2748
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2749
        plaintext = testament.as_short_text()
 
2750
 
 
2751
        return gpg_strategy.verify(signature, plaintext)
1720
2752
 
1721
2753
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1722
2754
        self._ensure_real()
1723
2755
        return self._real_repository.item_keys_introduced_by(revision_ids,
1724
2756
            _files_pb=_files_pb)
1725
2757
 
1726
 
    def revision_graph_can_have_wrong_parents(self):
1727
 
        # The answer depends on the remote repo format.
1728
 
        self._ensure_real()
1729
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1730
 
 
1731
2758
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1732
2759
        self._ensure_real()
1733
2760
        return self._real_repository._find_inconsistent_revision_parents(
1741
2768
        providers = [self._unstacked_provider]
1742
2769
        if other is not None:
1743
2770
            providers.insert(0, other)
1744
 
        providers.extend(r._make_parents_provider() for r in
1745
 
                         self._fallback_repositories)
1746
 
        return graph.StackedParentsProvider(providers)
 
2771
        return graph.StackedParentsProvider(_LazyListJoin(
 
2772
            providers, self._fallback_repositories))
1747
2773
 
1748
2774
    def _serialise_search_recipe(self, recipe):
1749
2775
        """Serialise a graph search recipe.
1757
2783
        return '\n'.join((start_keys, stop_keys, count))
1758
2784
 
1759
2785
    def _serialise_search_result(self, search_result):
1760
 
        if isinstance(search_result, graph.PendingAncestryResult):
1761
 
            parts = ['ancestry-of']
1762
 
            parts.extend(search_result.heads)
1763
 
        else:
1764
 
            recipe = search_result.get_recipe()
1765
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2786
        parts = search_result.get_network_struct()
1766
2787
        return '\n'.join(parts)
1767
2788
 
1768
2789
    def autopack(self):
1769
 
        path = self.bzrdir._path_for_remote_call(self._client)
 
2790
        path = self.controldir._path_for_remote_call(self._client)
1770
2791
        try:
1771
2792
            response = self._call('PackRepository.autopack', path)
1772
2793
        except errors.UnknownSmartMethod:
1778
2799
            raise errors.UnexpectedSmartServerResponse(response)
1779
2800
 
1780
2801
 
1781
 
class RemoteStreamSink(repository.StreamSink):
 
2802
class RemoteStreamSink(vf_repository.StreamSink):
1782
2803
 
1783
2804
    def _insert_real(self, stream, src_format, resume_tokens):
1784
2805
        self.target_repo._ensure_real()
1800
2821
            lock_args = ()
1801
2822
        client = target._client
1802
2823
        medium = client._medium
1803
 
        path = target.bzrdir._path_for_remote_call(client)
 
2824
        path = target.controldir._path_for_remote_call(client)
1804
2825
        # Probe for the verb to use with an empty stream before sending the
1805
2826
        # real stream to it.  We do this both to avoid the risk of sending a
1806
2827
        # large request that is then rejected, and because we don't want to
1885
2906
        self._last_substream and self._last_stream so that the stream can be
1886
2907
        resumed by _resume_stream_with_vfs.
1887
2908
        """
1888
 
                    
 
2909
 
1889
2910
        stream_iter = iter(stream)
1890
2911
        for substream_kind, substream in stream_iter:
1891
2912
            if substream_kind == 'inventory-deltas':
1894
2915
                return
1895
2916
            else:
1896
2917
                yield substream_kind, substream
1897
 
            
1898
 
 
1899
 
class RemoteStreamSource(repository.StreamSource):
 
2918
 
 
2919
 
 
2920
class RemoteStreamSource(vf_repository.StreamSource):
1900
2921
    """Stream data from a remote server."""
1901
2922
 
1902
2923
    def get_stream(self, search):
1923
2944
 
1924
2945
    def _real_stream(self, repo, search):
1925
2946
        """Get a stream for search from repo.
1926
 
        
1927
 
        This never called RemoteStreamSource.get_stream, and is a heler
1928
 
        for RemoteStreamSource._get_stream to allow getting a stream 
 
2947
 
 
2948
        This never called RemoteStreamSource.get_stream, and is a helper
 
2949
        for RemoteStreamSource._get_stream to allow getting a stream
1929
2950
        reliably whether fallback back because of old servers or trying
1930
2951
        to stream from a non-RemoteRepository (which the stacked support
1931
2952
        code will do).
1956
2977
            return self._real_stream(repo, search)
1957
2978
        client = repo._client
1958
2979
        medium = client._medium
1959
 
        path = repo.bzrdir._path_for_remote_call(client)
 
2980
        path = repo.controldir._path_for_remote_call(client)
1960
2981
        search_bytes = repo._serialise_search_result(search)
1961
2982
        args = (path, self.to_format.network_name())
1962
2983
        candidate_verbs = [
1963
2984
            ('Repository.get_stream_1.19', (1, 19)),
1964
2985
            ('Repository.get_stream', (1, 13))]
 
2986
 
1965
2987
        found_verb = False
1966
2988
        for verb, version in candidate_verbs:
1967
2989
            if medium._is_remote_before(version):
1971
2993
                    verb, args, search_bytes)
1972
2994
            except errors.UnknownSmartMethod:
1973
2995
                medium._remember_remote_is_before(version)
 
2996
            except errors.UnknownErrorFromSmartServer as e:
 
2997
                if isinstance(search, vf_search.EverythingResult):
 
2998
                    error_verb = e.error_from_smart_server.error_verb
 
2999
                    if error_verb == 'BadSearch':
 
3000
                        # Pre-2.4 servers don't support this sort of search.
 
3001
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
3002
                        # good idea in general?  It might provide a little bit
 
3003
                        # of protection against client-side bugs.
 
3004
                        medium._remember_remote_is_before((2, 4))
 
3005
                        break
 
3006
                raise
1974
3007
            else:
1975
3008
                response_tuple, response_handler = response
1976
3009
                found_verb = True
1980
3013
        if response_tuple[0] != 'ok':
1981
3014
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
3015
        byte_stream = response_handler.read_streamed_body()
1983
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
3016
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
3017
            self._record_counter)
1984
3018
        if src_format.network_name() != repo._format.network_name():
1985
3019
            raise AssertionError(
1986
3020
                "Mismatched RemoteRepository and stream src %r, %r" % (
2030
3064
    """
2031
3065
 
2032
3066
    def __init__(self, bzrdir, _client):
2033
 
        self.bzrdir = bzrdir
 
3067
        self.controldir = bzrdir
2034
3068
        self._client = _client
2035
3069
        self._need_find_modes = True
2036
3070
        LockableFiles.__init__(
2058
3092
 
2059
3093
    def _ensure_real(self):
2060
3094
        if self._custom_format is None:
2061
 
            self._custom_format = branch.network_format_registry.get(
2062
 
                self._network_name)
 
3095
            try:
 
3096
                self._custom_format = branch.network_format_registry.get(
 
3097
                    self._network_name)
 
3098
            except KeyError:
 
3099
                raise errors.UnknownFormatError(kind='branch',
 
3100
                    format=self._network_name)
2063
3101
 
2064
3102
    def get_format_description(self):
2065
3103
        self._ensure_real()
2068
3106
    def network_name(self):
2069
3107
        return self._network_name
2070
3108
 
2071
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2072
 
        return a_bzrdir.open_branch(name=name, 
 
3109
    def open(self, a_controldir, name=None, ignore_fallbacks=False):
 
3110
        return a_controldir.open_branch(name=name, 
2073
3111
            ignore_fallbacks=ignore_fallbacks)
2074
3112
 
2075
 
    def _vfs_initialize(self, a_bzrdir, name):
 
3113
    def _vfs_initialize(self, a_controldir, name, append_revisions_only,
 
3114
                        repository=None):
2076
3115
        # Initialisation when using a local bzrdir object, or a non-vfs init
2077
3116
        # method is not available on the server.
2078
3117
        # self._custom_format is always set - the start of initialize ensures
2079
3118
        # that.
2080
 
        if isinstance(a_bzrdir, RemoteBzrDir):
2081
 
            a_bzrdir._ensure_real()
2082
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2083
 
                name)
 
3119
        if isinstance(a_controldir, RemoteBzrDir):
 
3120
            a_controldir._ensure_real()
 
3121
            result = self._custom_format.initialize(a_controldir._real_bzrdir,
 
3122
                name=name, append_revisions_only=append_revisions_only,
 
3123
                repository=repository)
2084
3124
        else:
2085
3125
            # We assume the bzrdir is parameterised; it may not be.
2086
 
            result = self._custom_format.initialize(a_bzrdir, name)
2087
 
        if (isinstance(a_bzrdir, RemoteBzrDir) and
 
3126
            result = self._custom_format.initialize(a_controldir, name=name,
 
3127
                append_revisions_only=append_revisions_only,
 
3128
                repository=repository)
 
3129
        if (isinstance(a_controldir, RemoteBzrDir) and
2088
3130
            not isinstance(result, RemoteBranch)):
2089
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
3131
            result = RemoteBranch(a_controldir, a_controldir.find_repository(), result,
2090
3132
                                  name=name)
2091
3133
        return result
2092
3134
 
2093
 
    def initialize(self, a_bzrdir, name=None):
 
3135
    def initialize(self, a_controldir, name=None, repository=None,
 
3136
                   append_revisions_only=None):
 
3137
        if name is None:
 
3138
            name = a_controldir._get_selected_branch()
2094
3139
        # 1) get the network name to use.
2095
3140
        if self._custom_format:
2096
3141
            network_name = self._custom_format.network_name()
2097
3142
        else:
2098
 
            # Select the current bzrlib default and ask for that.
2099
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3143
            # Select the current breezy default and ask for that.
 
3144
            reference_bzrdir_format = controldir.format_registry.get('default')()
2100
3145
            reference_format = reference_bzrdir_format.get_branch_format()
2101
3146
            self._custom_format = reference_format
2102
3147
            network_name = reference_format.network_name()
2103
3148
        # Being asked to create on a non RemoteBzrDir:
2104
 
        if not isinstance(a_bzrdir, RemoteBzrDir):
2105
 
            return self._vfs_initialize(a_bzrdir, name=name)
2106
 
        medium = a_bzrdir._client._medium
 
3149
        if not isinstance(a_controldir, RemoteBzrDir):
 
3150
            return self._vfs_initialize(a_controldir, name=name,
 
3151
                append_revisions_only=append_revisions_only,
 
3152
                repository=repository)
 
3153
        medium = a_controldir._client._medium
2107
3154
        if medium._is_remote_before((1, 13)):
2108
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3155
            return self._vfs_initialize(a_controldir, name=name,
 
3156
                append_revisions_only=append_revisions_only,
 
3157
                repository=repository)
2109
3158
        # Creating on a remote bzr dir.
2110
3159
        # 2) try direct creation via RPC
2111
 
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2112
 
        if name is not None:
 
3160
        path = a_controldir._path_for_remote_call(a_controldir._client)
 
3161
        if name != "":
2113
3162
            # XXX JRV20100304: Support creating colocated branches
2114
3163
            raise errors.NoColocatedBranchSupport(self)
2115
3164
        verb = 'BzrDir.create_branch'
2116
3165
        try:
2117
 
            response = a_bzrdir._call(verb, path, network_name)
 
3166
            response = a_controldir._call(verb, path, network_name)
2118
3167
        except errors.UnknownSmartMethod:
2119
3168
            # Fallback - use vfs methods
2120
3169
            medium._remember_remote_is_before((1, 13))
2121
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3170
            return self._vfs_initialize(a_controldir, name=name,
 
3171
                    append_revisions_only=append_revisions_only,
 
3172
                    repository=repository)
2122
3173
        if response[0] != 'ok':
2123
3174
            raise errors.UnexpectedSmartServerResponse(response)
2124
3175
        # Turn the response into a RemoteRepository object.
2125
3176
        format = RemoteBranchFormat(network_name=response[1])
2126
3177
        repo_format = response_tuple_to_repo_format(response[3:])
2127
 
        if response[2] == '':
2128
 
            repo_bzrdir = a_bzrdir
 
3178
        repo_path = response[2]
 
3179
        if repository is not None:
 
3180
            remote_repo_url = urlutils.join(a_controldir.user_url, repo_path)
 
3181
            url_diff = urlutils.relative_url(repository.user_url,
 
3182
                    remote_repo_url)
 
3183
            if url_diff != '.':
 
3184
                raise AssertionError(
 
3185
                    'repository.user_url %r does not match URL from server '
 
3186
                    'response (%r + %r)'
 
3187
                    % (repository.user_url, a_controldir.user_url, repo_path))
 
3188
            remote_repo = repository
2129
3189
        else:
2130
 
            repo_bzrdir = RemoteBzrDir(
2131
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2132
 
                a_bzrdir._client)
2133
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2134
 
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
 
3190
            if repo_path == '':
 
3191
                repo_bzrdir = a_controldir
 
3192
            else:
 
3193
                repo_bzrdir = RemoteBzrDir(
 
3194
                    a_controldir.root_transport.clone(repo_path), a_controldir._format,
 
3195
                    a_controldir._client)
 
3196
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
3197
        remote_branch = RemoteBranch(a_controldir, remote_repo,
2135
3198
            format=format, setup_stacking=False, name=name)
 
3199
        if append_revisions_only:
 
3200
            remote_branch.set_append_revisions_only(append_revisions_only)
2136
3201
        # XXX: We know this is a new branch, so it must have revno 0, revid
2137
3202
        # NULL_REVISION. Creating the branch locked would make this be unable
2138
3203
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2157
3222
        self._ensure_real()
2158
3223
        return self._custom_format.supports_set_append_revisions_only()
2159
3224
 
 
3225
    def _use_default_local_heads_to_fetch(self):
 
3226
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3227
        # implementation is not overridden vs the base class, we can use the
 
3228
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3229
        # usually cheaper in terms of net round trips, as the last-revision and
 
3230
        # tags info fetched is cached and would be fetched anyway.
 
3231
        self._ensure_real()
 
3232
        if isinstance(self._custom_format, bzrbranch.BranchFormatMetadir):
 
3233
            branch_class = self._custom_format._branch_class()
 
3234
            heads_to_fetch_impl = branch_class.heads_to_fetch.__func__
 
3235
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.__func__:
 
3236
                return True
 
3237
        return False
 
3238
 
 
3239
 
 
3240
class RemoteBranchStore(_mod_config.IniFileStore):
 
3241
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3242
 
 
3243
    Note that this is specific to bzr-based formats.
 
3244
    """
 
3245
 
 
3246
    def __init__(self, branch):
 
3247
        super(RemoteBranchStore, self).__init__()
 
3248
        self.branch = branch
 
3249
        self.id = "branch"
 
3250
        self._real_store = None
 
3251
 
 
3252
    def external_url(self):
 
3253
        return urlutils.join(self.branch.user_url, 'branch.conf')
 
3254
 
 
3255
    def _load_content(self):
 
3256
        path = self.branch._remote_path()
 
3257
        try:
 
3258
            response, handler = self.branch._call_expecting_body(
 
3259
                'Branch.get_config_file', path)
 
3260
        except errors.UnknownSmartMethod:
 
3261
            self._ensure_real()
 
3262
            return self._real_store._load_content()
 
3263
        if len(response) and response[0] != 'ok':
 
3264
            raise errors.UnexpectedSmartServerResponse(response)
 
3265
        return handler.read_body_bytes()
 
3266
 
 
3267
    def _save_content(self, content):
 
3268
        path = self.branch._remote_path()
 
3269
        try:
 
3270
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3271
                'Branch.put_config_file', (path,
 
3272
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3273
                content)
 
3274
        except errors.UnknownSmartMethod:
 
3275
            self._ensure_real()
 
3276
            return self._real_store._save_content(content)
 
3277
        handler.cancel_read_body()
 
3278
        if response != ('ok', ):
 
3279
            raise errors.UnexpectedSmartServerResponse(response)
 
3280
 
 
3281
    def _ensure_real(self):
 
3282
        self.branch._ensure_real()
 
3283
        if self._real_store is None:
 
3284
            self._real_store = _mod_config.BranchStore(self.branch)
 
3285
 
2160
3286
 
2161
3287
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2162
3288
    """Branch stored on a server accessed by HPSS RPC.
2165
3291
    """
2166
3292
 
2167
3293
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2168
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3294
        _client=None, format=None, setup_stacking=True, name=None,
 
3295
        possible_transports=None):
2169
3296
        """Create a RemoteBranch instance.
2170
3297
 
2171
3298
        :param real_branch: An optional local implementation of the branch
2182
3309
        # We intentionally don't call the parent class's __init__, because it
2183
3310
        # will try to assign to self.tags, which is a property in this subclass.
2184
3311
        # And the parent's __init__ doesn't do much anyway.
2185
 
        self.bzrdir = remote_bzrdir
 
3312
        self.controldir = remote_bzrdir
 
3313
        self.name = name
2186
3314
        if _client is not None:
2187
3315
            self._client = _client
2188
3316
        else:
2200
3328
            self._real_branch.repository = self.repository
2201
3329
        else:
2202
3330
            self._real_branch = None
2203
 
        # Fill out expected attributes of branch for bzrlib API users.
 
3331
        # Fill out expected attributes of branch for breezy API users.
2204
3332
        self._clear_cached_state()
2205
3333
        # TODO: deprecate self.base in favor of user_url
2206
 
        self.base = self.bzrdir.user_url
 
3334
        self.base = self.controldir.user_url
2207
3335
        self._name = name
2208
3336
        self._control_files = None
2209
3337
        self._lock_mode = None
2211
3339
        self._repo_lock_token = None
2212
3340
        self._lock_count = 0
2213
3341
        self._leave_lock = False
 
3342
        self.conf_store = None
2214
3343
        # Setup a format: note that we cannot call _ensure_real until all the
2215
3344
        # attributes above are set: This code cannot be moved higher up in this
2216
3345
        # function.
2236
3365
            hook(self)
2237
3366
        self._is_stacked = False
2238
3367
        if setup_stacking:
2239
 
            self._setup_stacking()
 
3368
            self._setup_stacking(possible_transports)
2240
3369
 
2241
 
    def _setup_stacking(self):
 
3370
    def _setup_stacking(self, possible_transports):
2242
3371
        # configure stacking into the remote repository, by reading it from
2243
3372
        # the vfs branch.
2244
3373
        try:
2245
3374
            fallback_url = self.get_stacked_on_url()
2246
3375
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2247
 
            errors.UnstackableRepositoryFormat), e:
 
3376
            errors.UnstackableRepositoryFormat) as e:
2248
3377
            return
2249
3378
        self._is_stacked = True
2250
 
        self._activate_fallback_location(fallback_url)
 
3379
        if possible_transports is None:
 
3380
            possible_transports = []
 
3381
        else:
 
3382
            possible_transports = list(possible_transports)
 
3383
        possible_transports.append(self.controldir.root_transport)
 
3384
        self._activate_fallback_location(fallback_url,
 
3385
            possible_transports=possible_transports)
2251
3386
 
2252
3387
    def _get_config(self):
2253
3388
        return RemoteBranchConfig(self)
2254
3389
 
 
3390
    def _get_config_store(self):
 
3391
        if self.conf_store is None:
 
3392
            self.conf_store =  RemoteBranchStore(self)
 
3393
        return self.conf_store
 
3394
 
 
3395
    def store_uncommitted(self, creator):
 
3396
        self._ensure_real()
 
3397
        return self._real_branch.store_uncommitted(creator)
 
3398
 
 
3399
    def get_unshelver(self, tree):
 
3400
        self._ensure_real()
 
3401
        return self._real_branch.get_unshelver(tree)
 
3402
 
2255
3403
    def _get_real_transport(self):
2256
3404
        # if we try vfs access, return the real branch's vfs transport
2257
3405
        self._ensure_real()
2273
3421
            if not vfs.vfs_enabled():
2274
3422
                raise AssertionError('smart server vfs must be enabled '
2275
3423
                    'to use vfs implementation')
2276
 
            self.bzrdir._ensure_real()
2277
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
 
3424
            self.controldir._ensure_real()
 
3425
            self._real_branch = self.controldir._real_bzrdir.open_branch(
2278
3426
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
3427
            # The remote branch and the real branch shares the same store. If
 
3428
            # we don't, there will always be cases where one of the stores
 
3429
            # doesn't see an update made on the other.
 
3430
            self._real_branch.conf_store = self.conf_store
2279
3431
            if self.repository._real_repository is None:
2280
3432
                # Give the remote repository the matching real repo.
2281
3433
                real_repo = self._real_branch.repository
2317
3469
        # because it triggers an _ensure_real that we otherwise might not need.
2318
3470
        if self._control_files is None:
2319
3471
            self._control_files = RemoteBranchLockableFiles(
2320
 
                self.bzrdir, self._client)
 
3472
                self.controldir, self._client)
2321
3473
        return self._control_files
2322
3474
 
2323
 
    def _get_checkout_format(self):
2324
 
        self._ensure_real()
2325
 
        return self._real_branch._get_checkout_format()
2326
 
 
2327
3475
    def get_physical_lock_status(self):
2328
3476
        """See Branch.get_physical_lock_status()."""
2329
 
        # should be an API call to the server, as branches must be lockable.
2330
 
        self._ensure_real()
2331
 
        return self._real_branch.get_physical_lock_status()
 
3477
        try:
 
3478
            response = self._client.call('Branch.get_physical_lock_status',
 
3479
                self._remote_path())
 
3480
        except errors.UnknownSmartMethod:
 
3481
            self._ensure_real()
 
3482
            return self._real_branch.get_physical_lock_status()
 
3483
        if response[0] not in ('yes', 'no'):
 
3484
            raise errors.UnexpectedSmartServerResponse(response)
 
3485
        return (response[0] == 'yes')
2332
3486
 
2333
3487
    def get_stacked_on_url(self):
2334
3488
        """Get the URL this branch is stacked against.
2344
3498
            # self._translate_error, so we can't use self._call either.
2345
3499
            response = self._client.call('Branch.get_stacked_on_url',
2346
3500
                self._remote_path())
2347
 
        except errors.ErrorFromSmartServer, err:
 
3501
        except errors.ErrorFromSmartServer as err:
2348
3502
            # there may not be a repository yet, so we can't call through
2349
3503
            # its _translate_error
2350
3504
            _translate_error(err, branch=self)
2351
 
        except errors.UnknownSmartMethod, err:
 
3505
        except errors.UnknownSmartMethod as err:
2352
3506
            self._ensure_real()
2353
3507
            return self._real_branch.get_stacked_on_url()
2354
3508
        if response[0] != 'ok':
2357
3511
 
2358
3512
    def set_stacked_on_url(self, url):
2359
3513
        branch.Branch.set_stacked_on_url(self, url)
 
3514
        # We need the stacked_on_url to be visible both locally (to not query
 
3515
        # it repeatedly) and remotely (so smart verbs can get it server side)
 
3516
        # Without the following line,
 
3517
        # breezy.tests.per_branch.test_create_clone.TestCreateClone
 
3518
        # .test_create_clone_on_transport_stacked_hooks_get_stacked_branch
 
3519
        # fails for remote branches -- vila 2012-01-04
 
3520
        self.conf_store.save_changes()
2360
3521
        if not url:
2361
3522
            self._is_stacked = False
2362
3523
        else:
2363
3524
            self._is_stacked = True
2364
 
        
 
3525
 
2365
3526
    def _vfs_get_tags_bytes(self):
2366
3527
        self._ensure_real()
2367
3528
        return self._real_branch._get_tags_bytes()
2368
3529
 
 
3530
    @needs_read_lock
2369
3531
    def _get_tags_bytes(self):
 
3532
        if self._tags_bytes is None:
 
3533
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3534
        return self._tags_bytes
 
3535
 
 
3536
    def _get_tags_bytes_via_hpss(self):
2370
3537
        medium = self._client._medium
2371
3538
        if medium._is_remote_before((1, 13)):
2372
3539
            return self._vfs_get_tags_bytes()
2382
3549
        return self._real_branch._set_tags_bytes(bytes)
2383
3550
 
2384
3551
    def _set_tags_bytes(self, bytes):
 
3552
        if self.is_locked():
 
3553
            self._tags_bytes = bytes
2385
3554
        medium = self._client._medium
2386
3555
        if medium._is_remote_before((1, 18)):
2387
3556
            self._vfs_set_tags_bytes(bytes)
2398
3567
    def lock_read(self):
2399
3568
        """Lock the branch for read operations.
2400
3569
 
2401
 
        :return: A bzrlib.lock.LogicalLockResult.
 
3570
        :return: A breezy.lock.LogicalLockResult.
2402
3571
        """
2403
3572
        self.repository.lock_read()
2404
3573
        if not self._lock_mode:
2419
3588
            repo_token = self.repository.lock_write().repository_token
2420
3589
            self.repository.unlock()
2421
3590
        err_context = {'token': token}
2422
 
        response = self._call(
2423
 
            'Branch.lock_write', self._remote_path(), branch_token,
2424
 
            repo_token or '', **err_context)
 
3591
        try:
 
3592
            response = self._call(
 
3593
                'Branch.lock_write', self._remote_path(), branch_token,
 
3594
                repo_token or '', **err_context)
 
3595
        except errors.LockContention as e:
 
3596
            # The LockContention from the server doesn't have any
 
3597
            # information about the lock_url. We re-raise LockContention
 
3598
            # with valid lock_url.
 
3599
            raise errors.LockContention('(remote lock)',
 
3600
                self.repository.base.split('.bzr/')[0])
2425
3601
        if response[0] != 'ok':
2426
3602
            raise errors.UnexpectedSmartServerResponse(response)
2427
3603
        ok, branch_token, repo_token = response
2448
3624
            self._lock_mode = 'w'
2449
3625
            self._lock_count = 1
2450
3626
        elif self._lock_mode == 'r':
2451
 
            raise errors.ReadOnlyTransaction
 
3627
            raise errors.ReadOnlyError(self)
2452
3628
        else:
2453
3629
            if token is not None:
2454
3630
                # A token was given to lock_write, and we're relocking, so
2475
3651
        try:
2476
3652
            self._lock_count -= 1
2477
3653
            if not self._lock_count:
 
3654
                if self.conf_store is not None:
 
3655
                    self.conf_store.save_changes()
2478
3656
                self._clear_cached_state()
2479
3657
                mode = self._lock_mode
2480
3658
                self._lock_mode = None
2503
3681
            self.repository.unlock()
2504
3682
 
2505
3683
    def break_lock(self):
2506
 
        self._ensure_real()
2507
 
        return self._real_branch.break_lock()
 
3684
        try:
 
3685
            response = self._call(
 
3686
                'Branch.break_lock', self._remote_path())
 
3687
        except errors.UnknownSmartMethod:
 
3688
            self._ensure_real()
 
3689
            return self._real_branch.break_lock()
 
3690
        if response != ('ok',):
 
3691
            raise errors.UnexpectedSmartServerResponse(response)
2508
3692
 
2509
3693
    def leave_lock_in_place(self):
2510
3694
        if not self._lock_token:
2534
3718
            missing_parent = parent_map[missing_parent]
2535
3719
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2536
3720
 
2537
 
    def _last_revision_info(self):
 
3721
    def _read_last_revision_info(self):
2538
3722
        response = self._call('Branch.last_revision_info', self._remote_path())
2539
3723
        if response[0] != 'ok':
2540
3724
            raise SmartProtocolError('unexpected response code %s' % (response,))
2557
3741
        return result
2558
3742
 
2559
3743
    def _remote_path(self):
2560
 
        return self.bzrdir._path_for_remote_call(self._client)
 
3744
        return self.controldir._path_for_remote_call(self._client)
2561
3745
 
2562
3746
    def _set_last_revision_descendant(self, revision_id, other_branch,
2563
3747
            allow_diverged=False, allow_overwrite_descendant=False):
2603
3787
            raise errors.UnexpectedSmartServerResponse(response)
2604
3788
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2605
3789
 
2606
 
    @needs_write_lock
2607
 
    def set_revision_history(self, rev_history):
2608
 
        # Send just the tip revision of the history; the server will generate
2609
 
        # the full history from that.  If the revision doesn't exist in this
2610
 
        # branch, NoSuchRevision will be raised.
2611
 
        if rev_history == []:
2612
 
            rev_id = 'null:'
2613
 
        else:
2614
 
            rev_id = rev_history[-1]
2615
 
        self._set_last_revision(rev_id)
2616
 
        for hook in branch.Branch.hooks['set_rh']:
2617
 
            hook(self, rev_history)
2618
 
        self._cache_revision_history(rev_history)
2619
 
 
2620
3790
    def _get_parent_location(self):
2621
3791
        medium = self._client._medium
2622
3792
        if medium._is_remote_before((1, 13)):
2643
3813
            return self._vfs_set_parent_location(url)
2644
3814
        try:
2645
3815
            call_url = url or ''
2646
 
            if type(call_url) is not str:
 
3816
            if not isinstance(call_url, str):
2647
3817
                raise AssertionError('url must be a str or None (%s)' % url)
2648
3818
            response = self._call('Branch.set_parent_location',
2649
3819
                self._remote_path(), self._lock_token, self._repo_lock_token,
2668
3838
            _override_hook_target=self, **kwargs)
2669
3839
 
2670
3840
    @needs_read_lock
2671
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3841
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2672
3842
        self._ensure_real()
2673
3843
        return self._real_branch.push(
2674
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3844
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2675
3845
            _override_hook_source_branch=self)
2676
3846
 
 
3847
    def peek_lock_mode(self):
 
3848
        return self._lock_mode
 
3849
 
2677
3850
    def is_locked(self):
2678
3851
        return self._lock_count >= 1
2679
3852
 
2680
3853
    @needs_read_lock
 
3854
    def revision_id_to_dotted_revno(self, revision_id):
 
3855
        """Given a revision id, return its dotted revno.
 
3856
 
 
3857
        :return: a tuple like (1,) or (400,1,3).
 
3858
        """
 
3859
        try:
 
3860
            response = self._call('Branch.revision_id_to_revno',
 
3861
                self._remote_path(), revision_id)
 
3862
        except errors.UnknownSmartMethod:
 
3863
            self._ensure_real()
 
3864
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3865
        if response[0] == 'ok':
 
3866
            return tuple([int(x) for x in response[1:]])
 
3867
        else:
 
3868
            raise errors.UnexpectedSmartServerResponse(response)
 
3869
 
 
3870
    @needs_read_lock
2681
3871
    def revision_id_to_revno(self, revision_id):
2682
 
        self._ensure_real()
2683
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3872
        """Given a revision id on the branch mainline, return its revno.
 
3873
 
 
3874
        :return: an integer
 
3875
        """
 
3876
        try:
 
3877
            response = self._call('Branch.revision_id_to_revno',
 
3878
                self._remote_path(), revision_id)
 
3879
        except errors.UnknownSmartMethod:
 
3880
            self._ensure_real()
 
3881
            return self._real_branch.revision_id_to_revno(revision_id)
 
3882
        if response[0] == 'ok':
 
3883
            if len(response) == 2:
 
3884
                return int(response[1])
 
3885
            raise NoSuchRevision(self, revision_id)
 
3886
        else:
 
3887
            raise errors.UnexpectedSmartServerResponse(response)
2684
3888
 
2685
3889
    @needs_write_lock
2686
3890
    def set_last_revision_info(self, revno, revision_id):
2687
3891
        # XXX: These should be returned by the set_last_revision_info verb
2688
3892
        old_revno, old_revid = self.last_revision_info()
2689
3893
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2690
 
        revision_id = ensure_null(revision_id)
 
3894
        if not revision_id or not isinstance(revision_id, basestring):
 
3895
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2691
3896
        try:
2692
3897
            response = self._call('Branch.set_last_revision_info',
2693
3898
                self._remote_path(), self._lock_token, self._repo_lock_token,
2722
3927
            except errors.UnknownSmartMethod:
2723
3928
                medium._remember_remote_is_before((1, 6))
2724
3929
        self._clear_cached_state_of_remote_branch_only()
2725
 
        self.set_revision_history(self._lefthand_history(revision_id,
2726
 
            last_rev=last_rev,other_branch=other_branch))
 
3930
        graph = self.repository.get_graph()
 
3931
        (last_revno, last_revid) = self.last_revision_info()
 
3932
        known_revision_ids = [
 
3933
            (last_revid, last_revno),
 
3934
            (_mod_revision.NULL_REVISION, 0),
 
3935
            ]
 
3936
        if last_rev is not None:
 
3937
            if not graph.is_ancestor(last_rev, revision_id):
 
3938
                # our previous tip is not merged into stop_revision
 
3939
                raise errors.DivergedBranches(self, other_branch)
 
3940
        revno = graph.find_distance_to_null(revision_id, known_revision_ids)
 
3941
        self.set_last_revision_info(revno, revision_id)
2727
3942
 
2728
3943
    def set_push_location(self, location):
 
3944
        self._set_config_location('push_location', location)
 
3945
 
 
3946
    def heads_to_fetch(self):
 
3947
        if self._format._use_default_local_heads_to_fetch():
 
3948
            # We recognise this format, and its heads-to-fetch implementation
 
3949
            # is the default one (tip + tags).  In this case it's cheaper to
 
3950
            # just use the default implementation rather than a special RPC as
 
3951
            # the tip and tags data is cached.
 
3952
            return branch.Branch.heads_to_fetch(self)
 
3953
        medium = self._client._medium
 
3954
        if medium._is_remote_before((2, 4)):
 
3955
            return self._vfs_heads_to_fetch()
 
3956
        try:
 
3957
            return self._rpc_heads_to_fetch()
 
3958
        except errors.UnknownSmartMethod:
 
3959
            medium._remember_remote_is_before((2, 4))
 
3960
            return self._vfs_heads_to_fetch()
 
3961
 
 
3962
    def _rpc_heads_to_fetch(self):
 
3963
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3964
        if len(response) != 2:
 
3965
            raise errors.UnexpectedSmartServerResponse(response)
 
3966
        must_fetch, if_present_fetch = response
 
3967
        return set(must_fetch), set(if_present_fetch)
 
3968
 
 
3969
    def _vfs_heads_to_fetch(self):
2729
3970
        self._ensure_real()
2730
 
        return self._real_branch.set_push_location(location)
 
3971
        return self._real_branch.heads_to_fetch()
2731
3972
 
2732
3973
 
2733
3974
class RemoteConfig(object):
2735
3976
 
2736
3977
    It is a low-level object that considers config data to be name/value pairs
2737
3978
    that may be associated with a section. Assigning meaning to the these
2738
 
    values is done at higher levels like bzrlib.config.TreeConfig.
 
3979
    values is done at higher levels like breezy.config.TreeConfig.
2739
3980
    """
2740
3981
 
2741
3982
    def get_option(self, name, section=None, default=None):
2748
3989
        """
2749
3990
        try:
2750
3991
            configobj = self._get_configobj()
 
3992
            section_obj = None
2751
3993
            if section is None:
2752
3994
                section_obj = configobj
2753
3995
            else:
2754
3996
                try:
2755
3997
                    section_obj = configobj[section]
2756
3998
                except KeyError:
2757
 
                    return default
2758
 
            return section_obj.get(name, default)
 
3999
                    pass
 
4000
            if section_obj is None:
 
4001
                value = default
 
4002
            else:
 
4003
                value = section_obj.get(name, default)
2759
4004
        except errors.UnknownSmartMethod:
2760
 
            return self._vfs_get_option(name, section, default)
 
4005
            value = self._vfs_get_option(name, section, default)
 
4006
        for hook in _mod_config.OldConfigHooks['get']:
 
4007
            hook(self, name, value)
 
4008
        return value
2761
4009
 
2762
4010
    def _response_to_configobj(self, response):
2763
4011
        if len(response[0]) and response[0][0] != 'ok':
2764
4012
            raise errors.UnexpectedSmartServerResponse(response)
2765
4013
        lines = response[1].read_body_bytes().splitlines()
2766
 
        return config.ConfigObj(lines, encoding='utf-8')
 
4014
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
4015
        for hook in _mod_config.OldConfigHooks['load']:
 
4016
            hook(self)
 
4017
        return conf
2767
4018
 
2768
4019
 
2769
4020
class RemoteBranchConfig(RemoteConfig):
2788
4039
        medium = self._branch._client._medium
2789
4040
        if medium._is_remote_before((1, 14)):
2790
4041
            return self._vfs_set_option(value, name, section)
 
4042
        if isinstance(value, dict):
 
4043
            if medium._is_remote_before((2, 2)):
 
4044
                return self._vfs_set_option(value, name, section)
 
4045
            return self._set_config_option_dict(value, name, section)
 
4046
        else:
 
4047
            return self._set_config_option(value, name, section)
 
4048
 
 
4049
    def _set_config_option(self, value, name, section):
2791
4050
        try:
2792
4051
            path = self._branch._remote_path()
2793
4052
            response = self._branch._client.call('Branch.set_config_option',
2794
4053
                path, self._branch._lock_token, self._branch._repo_lock_token,
2795
4054
                value.encode('utf8'), name, section or '')
2796
4055
        except errors.UnknownSmartMethod:
 
4056
            medium = self._branch._client._medium
2797
4057
            medium._remember_remote_is_before((1, 14))
2798
4058
            return self._vfs_set_option(value, name, section)
2799
4059
        if response != ():
2800
4060
            raise errors.UnexpectedSmartServerResponse(response)
2801
4061
 
 
4062
    def _serialize_option_dict(self, option_dict):
 
4063
        utf8_dict = {}
 
4064
        for key, value in option_dict.items():
 
4065
            if isinstance(key, unicode):
 
4066
                key = key.encode('utf8')
 
4067
            if isinstance(value, unicode):
 
4068
                value = value.encode('utf8')
 
4069
            utf8_dict[key] = value
 
4070
        return bencode.bencode(utf8_dict)
 
4071
 
 
4072
    def _set_config_option_dict(self, value, name, section):
 
4073
        try:
 
4074
            path = self._branch._remote_path()
 
4075
            serialised_dict = self._serialize_option_dict(value)
 
4076
            response = self._branch._client.call(
 
4077
                'Branch.set_config_option_dict',
 
4078
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4079
                serialised_dict, name, section or '')
 
4080
        except errors.UnknownSmartMethod:
 
4081
            medium = self._branch._client._medium
 
4082
            medium._remember_remote_is_before((2, 2))
 
4083
            return self._vfs_set_option(value, name, section)
 
4084
        if response != ():
 
4085
            raise errors.UnexpectedSmartServerResponse(response)
 
4086
 
2802
4087
    def _real_object(self):
2803
4088
        self._branch._ensure_real()
2804
4089
        return self._branch._real_branch
2843
4128
        return self._bzrdir._real_bzrdir
2844
4129
 
2845
4130
 
2846
 
 
2847
4131
def _extract_tar(tar, to_dir):
2848
4132
    """Extract all the contents of a tarfile object.
2849
4133
 
2853
4137
        tar.extract(tarinfo, to_dir)
2854
4138
 
2855
4139
 
 
4140
error_translators = registry.Registry()
 
4141
no_context_error_translators = registry.Registry()
 
4142
 
 
4143
 
2856
4144
def _translate_error(err, **context):
2857
4145
    """Translate an ErrorFromSmartServer into a more useful error.
2858
4146
 
2870
4158
    def find(name):
2871
4159
        try:
2872
4160
            return context[name]
2873
 
        except KeyError, key_err:
 
4161
        except KeyError as key_err:
2874
4162
            mutter('Missing key %r in context %r', key_err.args[0], context)
2875
4163
            raise err
2876
4164
    def get_path():
2879
4167
        """
2880
4168
        try:
2881
4169
            return context['path']
2882
 
        except KeyError, key_err:
 
4170
        except KeyError as key_err:
2883
4171
            try:
2884
4172
                return err.error_args[0]
2885
 
            except IndexError, idx_err:
 
4173
            except IndexError as idx_err:
2886
4174
                mutter(
2887
4175
                    'Missing key %r in context %r', key_err.args[0], context)
2888
4176
                raise err
2889
4177
 
2890
 
    if err.error_verb == 'IncompatibleRepositories':
2891
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2892
 
            err.error_args[1], err.error_args[2])
2893
 
    elif err.error_verb == 'NoSuchRevision':
2894
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2895
 
    elif err.error_verb == 'nosuchrevision':
2896
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2897
 
    elif err.error_verb == 'nobranch':
2898
 
        if len(err.error_args) >= 1:
2899
 
            extra = err.error_args[0]
2900
 
        else:
2901
 
            extra = None
2902
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2903
 
            detail=extra)
2904
 
    elif err.error_verb == 'norepository':
2905
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2906
 
    elif err.error_verb == 'LockContention':
2907
 
        raise errors.LockContention('(remote lock)')
2908
 
    elif err.error_verb == 'UnlockableTransport':
2909
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2910
 
    elif err.error_verb == 'LockFailed':
2911
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2912
 
    elif err.error_verb == 'TokenMismatch':
2913
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2914
 
    elif err.error_verb == 'Diverged':
2915
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2916
 
    elif err.error_verb == 'TipChangeRejected':
2917
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2918
 
    elif err.error_verb == 'UnstackableBranchFormat':
2919
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2920
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2921
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2922
 
    elif err.error_verb == 'NotStacked':
2923
 
        raise errors.NotStacked(branch=find('branch'))
2924
 
    elif err.error_verb == 'PermissionDenied':
2925
 
        path = get_path()
2926
 
        if len(err.error_args) >= 2:
2927
 
            extra = err.error_args[1]
2928
 
        else:
2929
 
            extra = None
2930
 
        raise errors.PermissionDenied(path, extra=extra)
2931
 
    elif err.error_verb == 'ReadError':
2932
 
        path = get_path()
2933
 
        raise errors.ReadError(path)
2934
 
    elif err.error_verb == 'NoSuchFile':
2935
 
        path = get_path()
2936
 
        raise errors.NoSuchFile(path)
2937
 
    elif err.error_verb == 'FileExists':
2938
 
        raise errors.FileExists(err.error_args[0])
2939
 
    elif err.error_verb == 'DirectoryNotEmpty':
2940
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2941
 
    elif err.error_verb == 'ShortReadvError':
2942
 
        args = err.error_args
2943
 
        raise errors.ShortReadvError(
2944
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2945
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
4178
    try:
 
4179
        translator = error_translators.get(err.error_verb)
 
4180
    except KeyError:
 
4181
        pass
 
4182
    else:
 
4183
        raise translator(err, find, get_path)
 
4184
    try:
 
4185
        translator = no_context_error_translators.get(err.error_verb)
 
4186
    except KeyError:
 
4187
        raise errors.UnknownErrorFromSmartServer(err)
 
4188
    else:
 
4189
        raise translator(err)
 
4190
 
 
4191
 
 
4192
error_translators.register('NoSuchRevision',
 
4193
    lambda err, find, get_path: NoSuchRevision(
 
4194
        find('branch'), err.error_args[0]))
 
4195
error_translators.register('nosuchrevision',
 
4196
    lambda err, find, get_path: NoSuchRevision(
 
4197
        find('repository'), err.error_args[0]))
 
4198
 
 
4199
def _translate_nobranch_error(err, find, get_path):
 
4200
    if len(err.error_args) >= 1:
 
4201
        extra = err.error_args[0]
 
4202
    else:
 
4203
        extra = None
 
4204
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4205
        detail=extra)
 
4206
 
 
4207
error_translators.register('nobranch', _translate_nobranch_error)
 
4208
error_translators.register('norepository',
 
4209
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4210
        find('bzrdir')))
 
4211
error_translators.register('UnlockableTransport',
 
4212
    lambda err, find, get_path: errors.UnlockableTransport(
 
4213
        find('bzrdir').root_transport))
 
4214
error_translators.register('TokenMismatch',
 
4215
    lambda err, find, get_path: errors.TokenMismatch(
 
4216
        find('token'), '(remote token)'))
 
4217
error_translators.register('Diverged',
 
4218
    lambda err, find, get_path: errors.DivergedBranches(
 
4219
        find('branch'), find('other_branch')))
 
4220
error_translators.register('NotStacked',
 
4221
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4222
 
 
4223
def _translate_PermissionDenied(err, find, get_path):
 
4224
    path = get_path()
 
4225
    if len(err.error_args) >= 2:
 
4226
        extra = err.error_args[1]
 
4227
    else:
 
4228
        extra = None
 
4229
    return errors.PermissionDenied(path, extra=extra)
 
4230
 
 
4231
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4232
error_translators.register('ReadError',
 
4233
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4234
error_translators.register('NoSuchFile',
 
4235
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4236
error_translators.register('TokenLockingNotSupported',
 
4237
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4238
        find('repository')))
 
4239
error_translators.register('UnsuspendableWriteGroup',
 
4240
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4241
        repository=find('repository')))
 
4242
error_translators.register('UnresumableWriteGroup',
 
4243
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4244
        repository=find('repository'), write_groups=err.error_args[0],
 
4245
        reason=err.error_args[1]))
 
4246
no_context_error_translators.register('IncompatibleRepositories',
 
4247
    lambda err: errors.IncompatibleRepositories(
 
4248
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4249
no_context_error_translators.register('LockContention',
 
4250
    lambda err: errors.LockContention('(remote lock)'))
 
4251
no_context_error_translators.register('LockFailed',
 
4252
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4253
no_context_error_translators.register('TipChangeRejected',
 
4254
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4255
no_context_error_translators.register('UnstackableBranchFormat',
 
4256
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4257
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4258
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4259
no_context_error_translators.register('FileExists',
 
4260
    lambda err: errors.FileExists(err.error_args[0]))
 
4261
no_context_error_translators.register('DirectoryNotEmpty',
 
4262
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4263
 
 
4264
def _translate_short_readv_error(err):
 
4265
    args = err.error_args
 
4266
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4267
        int(args[3]))
 
4268
 
 
4269
no_context_error_translators.register('ShortReadvError',
 
4270
    _translate_short_readv_error)
 
4271
 
 
4272
def _translate_unicode_error(err):
2946
4273
        encoding = str(err.error_args[0]) # encoding must always be a string
2947
4274
        val = err.error_args[1]
2948
4275
        start = int(err.error_args[2])
2956
4283
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2957
4284
        elif err.error_verb == 'UnicodeEncodeError':
2958
4285
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2959
 
    elif err.error_verb == 'ReadOnlyError':
2960
 
        raise errors.TransportNotPossible('readonly transport')
2961
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4286
 
 
4287
no_context_error_translators.register('UnicodeEncodeError',
 
4288
    _translate_unicode_error)
 
4289
no_context_error_translators.register('UnicodeDecodeError',
 
4290
    _translate_unicode_error)
 
4291
no_context_error_translators.register('ReadOnlyError',
 
4292
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4293
no_context_error_translators.register('MemoryError',
 
4294
    lambda err: errors.BzrError("remote server out of memory\n"
 
4295
        "Retry non-remotely, or contact the server admin for details."))
 
4296
no_context_error_translators.register('RevisionNotPresent',
 
4297
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4298
 
 
4299
no_context_error_translators.register('BzrCheckError',
 
4300
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4301