/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 bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-27 21:59:34 UTC
  • mto: This revision was merged to the branch mainline in revision 6452.
  • Revision ID: jelmer@samba.org-20120127215934-d5lupaxico234zn6
Convert 'suppress_warnings' option to config stacks.

Show diffs side-by-side

added added

removed removed

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