/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
  • Date: 2017-06-05 09:42:14 UTC
  • mto: This revision was merged to the branch mainline in revision 6666.
  • Revision ID: jelmer@jelmer.uk-20170605094214-iy8m1eay3skjasyf
Fix some more imports.

Show diffs side-by-side

added added

removed removed

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