/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: Jelmer Vernooij
  • Author(s): Richard Wilbur
  • Date: 2017-05-30 23:37:11 UTC
  • mto: This revision was merged to the branch mainline in revision 6645.
  • Revision ID: jelmer@jelmer.uk-20170530233711-r0m0qp8hpkqzpopw
https://launchpad.net/bugs/1537319
Fix order in which files are processed.

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