/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: Vincent Ladeuil
  • Date: 2012-01-05 13:02:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6434.
  • Revision ID: v.ladeuil+lp@free.fr-20120105130231-grtl31ovy72doqp9
Cleanup old blackbox tests and then some. Remove os.chdir() calls, caught a few bugs, make sure we don't leave file handles opened.

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):
248
628
        # as per meta1 formats - just delegate to the format object which may
249
629
        # be parameterised.
250
630
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
631
            name=name, repository=repository,
 
632
            append_revisions_only=append_revisions_only)
252
633
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
634
            if not isinstance(repository, RemoteRepository):
 
635
                raise AssertionError(
 
636
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
637
                    % (repository,))
 
638
            result = RemoteBranch(self, repository, real_branch, name=name)
255
639
        else:
256
640
            result = real_branch
257
641
        # BzrDir.clone_on_transport() uses the result of create_branch but does
265
649
 
266
650
    def destroy_branch(self, name=None):
267
651
        """See BzrDir.destroy_branch"""
268
 
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
652
        path = self._path_for_remote_call(self._client)
 
653
        try:
 
654
            if name is not None:
 
655
                args = (name, )
 
656
            else:
 
657
                args = ()
 
658
            response = self._call('BzrDir.destroy_branch', path, *args)
 
659
        except errors.UnknownSmartMethod:
 
660
            self._ensure_real()
 
661
            self._real_bzrdir.destroy_branch(name=name)
 
662
            self._next_open_branch_result = None
 
663
            return
270
664
        self._next_open_branch_result = None
 
665
        if response[0] != 'ok':
 
666
            raise SmartProtocolError('unexpected response code %s' % (response,))
271
667
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
668
    def create_workingtree(self, revision_id=None, from_branch=None,
 
669
        accelerator_tree=None, hardlink=False):
273
670
        raise errors.NotLocalUrl(self.transport.base)
274
671
 
275
 
    def find_branch_format(self):
 
672
    def find_branch_format(self, name=None):
276
673
        """Find the branch 'format' for this bzrdir.
277
674
 
278
675
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
676
        """
280
 
        b = self.open_branch()
 
677
        b = self.open_branch(name=name)
281
678
        return b._format
282
679
 
283
 
    def get_branch_reference(self):
 
680
    def get_branch_reference(self, name=None):
284
681
        """See BzrDir.get_branch_reference()."""
 
682
        if name is not None:
 
683
            # XXX JRV20100304: Support opening colocated branches
 
684
            raise errors.NoColocatedBranchSupport(self)
285
685
        response = self._get_branch_reference()
286
686
        if response[0] == 'ref':
287
687
            return response[1]
318
718
            raise errors.UnexpectedSmartServerResponse(response)
319
719
        return response
320
720
 
321
 
    def _get_tree_branch(self):
 
721
    def _get_tree_branch(self, name=None):
322
722
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
723
        return None, self.open_branch(name=name)
324
724
 
325
725
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
 
726
                    ignore_fallbacks=False, possible_transports=None):
327
727
        if unsupported:
328
728
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
729
        if self._next_open_branch_result is not None:
336
736
            # a branch reference, use the existing BranchReference logic.
337
737
            format = BranchReferenceFormat()
338
738
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
739
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
740
                possible_transports=possible_transports)
340
741
        branch_format_name = response[1]
341
742
        if not branch_format_name:
342
743
            branch_format_name = None
343
744
        format = RemoteBranchFormat(network_name=branch_format_name)
344
745
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
 
746
            setup_stacking=not ignore_fallbacks, name=name,
 
747
            possible_transports=possible_transports)
346
748
 
347
749
    def _open_repo_v1(self, path):
348
750
        verb = 'BzrDir.find_repository'
411
813
 
412
814
    def has_workingtree(self):
413
815
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
816
            path = self._path_for_remote_call(self._client)
 
817
            try:
 
818
                response = self._call('BzrDir.has_workingtree', path)
 
819
            except errors.UnknownSmartMethod:
 
820
                self._ensure_real()
 
821
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
822
            else:
 
823
                if response[0] not in ('yes', 'no'):
 
824
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
825
                self._has_working_tree = (response[0] == 'yes')
416
826
        return self._has_working_tree
417
827
 
418
828
    def open_workingtree(self, recommend_upgrade=True):
423
833
 
424
834
    def _path_for_remote_call(self, client):
425
835
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
836
        return urlutils.split_segment_parameters_raw(
 
837
            client.remote_path_from_transport(self.root_transport))[0]
427
838
 
428
839
    def get_branch_transport(self, branch_format, name=None):
429
840
        self._ensure_real()
441
852
        """Upgrading of remote bzrdirs is not supported yet."""
442
853
        return False
443
854
 
444
 
    def needs_format_conversion(self, format=None):
 
855
    def needs_format_conversion(self, format):
445
856
        """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
857
        return False
450
858
 
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
859
    def _get_config(self):
458
860
        return RemoteBzrDirConfig(self)
459
861
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
862
    def _get_config_store(self):
 
863
        return RemoteControlStore(self)
 
864
 
 
865
 
 
866
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
867
    """Format for repositories accessed over a _SmartClient.
463
868
 
464
869
    Instances of this repository are represented by RemoteRepository
479
884
    """
480
885
 
481
886
    _matchingbzrdir = RemoteBzrDirFormat()
 
887
    supports_full_versioned_files = True
 
888
    supports_leaving_lock = True
482
889
 
483
890
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
891
        _mod_repository.RepositoryFormat.__init__(self)
485
892
        self._custom_format = None
486
893
        self._network_name = None
487
894
        self._creating_bzrdir = None
 
895
        self._revision_graph_can_have_wrong_parents = None
488
896
        self._supports_chks = None
489
897
        self._supports_external_lookups = None
490
898
        self._supports_tree_reference = None
 
899
        self._supports_funky_characters = None
 
900
        self._supports_nesting_repositories = None
491
901
        self._rich_root_data = None
492
902
 
493
903
    def __repr__(self):
522
932
        return self._supports_external_lookups
523
933
 
524
934
    @property
 
935
    def supports_funky_characters(self):
 
936
        if self._supports_funky_characters is None:
 
937
            self._ensure_real()
 
938
            self._supports_funky_characters = \
 
939
                self._custom_format.supports_funky_characters
 
940
        return self._supports_funky_characters
 
941
 
 
942
    @property
 
943
    def supports_nesting_repositories(self):
 
944
        if self._supports_nesting_repositories is None:
 
945
            self._ensure_real()
 
946
            self._supports_nesting_repositories = \
 
947
                self._custom_format.supports_nesting_repositories
 
948
        return self._supports_nesting_repositories
 
949
 
 
950
    @property
525
951
    def supports_tree_reference(self):
526
952
        if self._supports_tree_reference is None:
527
953
            self._ensure_real()
529
955
                self._custom_format.supports_tree_reference
530
956
        return self._supports_tree_reference
531
957
 
 
958
    @property
 
959
    def revision_graph_can_have_wrong_parents(self):
 
960
        if self._revision_graph_can_have_wrong_parents is None:
 
961
            self._ensure_real()
 
962
            self._revision_graph_can_have_wrong_parents = \
 
963
                self._custom_format.revision_graph_can_have_wrong_parents
 
964
        return self._revision_graph_can_have_wrong_parents
 
965
 
532
966
    def _vfs_initialize(self, a_bzrdir, shared):
533
967
        """Helper for common code in initialize."""
534
968
        if self._custom_format:
569
1003
            network_name = self._network_name
570
1004
        else:
571
1005
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
1006
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
1007
            reference_format = reference_bzrdir_format.repository_format
574
1008
            network_name = reference_format.network_name()
575
1009
        # 2) try direct creation via RPC
601
1035
 
602
1036
    def _ensure_real(self):
603
1037
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
605
 
                self._network_name)
 
1038
            try:
 
1039
                self._custom_format = _mod_repository.network_format_registry.get(
 
1040
                    self._network_name)
 
1041
            except KeyError:
 
1042
                raise errors.UnknownFormatError(kind='repository',
 
1043
                    format=self._network_name)
606
1044
 
607
1045
    @property
608
1046
    def _fetch_order(self):
643
1081
        return self._custom_format._serializer
644
1082
 
645
1083
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1084
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1085
        lock._RelockDebugMixin):
648
1086
    """Repository accessed over rpc.
649
1087
 
650
1088
    For the moment most operations are performed using local transport-backed
674
1112
        self._format = format
675
1113
        self._lock_mode = None
676
1114
        self._lock_token = None
 
1115
        self._write_group_tokens = None
677
1116
        self._lock_count = 0
678
1117
        self._leave_lock = False
679
1118
        # Cache of revision parents; misses are cached during read locks, and
703
1142
        # transport, but I'm not sure it's worth making this method
704
1143
        # optional -- mbp 2010-04-21
705
1144
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1145
 
707
1146
    def __str__(self):
708
1147
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1148
 
719
1158
 
720
1159
        :param suppress_errors: see Repository.abort_write_group.
721
1160
        """
722
 
        self._ensure_real()
723
 
        return self._real_repository.abort_write_group(
724
 
            suppress_errors=suppress_errors)
 
1161
        if self._real_repository:
 
1162
            self._ensure_real()
 
1163
            return self._real_repository.abort_write_group(
 
1164
                suppress_errors=suppress_errors)
 
1165
        if not self.is_in_write_group():
 
1166
            if suppress_errors:
 
1167
                mutter('(suppressed) not in write group')
 
1168
                return
 
1169
            raise errors.BzrError("not in write group")
 
1170
        path = self.bzrdir._path_for_remote_call(self._client)
 
1171
        try:
 
1172
            response = self._call('Repository.abort_write_group', path,
 
1173
                self._lock_token, self._write_group_tokens)
 
1174
        except Exception, exc:
 
1175
            self._write_group = None
 
1176
            if not suppress_errors:
 
1177
                raise
 
1178
            mutter('abort_write_group failed')
 
1179
            log_exception_quietly()
 
1180
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1181
        else:
 
1182
            if response != ('ok', ):
 
1183
                raise errors.UnexpectedSmartServerResponse(response)
 
1184
            self._write_group_tokens = None
725
1185
 
726
1186
    @property
727
1187
    def chk_bytes(self):
741
1201
        for older plugins that don't use e.g. the CommitBuilder
742
1202
        facility.
743
1203
        """
744
 
        self._ensure_real()
745
 
        return self._real_repository.commit_write_group()
 
1204
        if self._real_repository:
 
1205
            self._ensure_real()
 
1206
            return self._real_repository.commit_write_group()
 
1207
        if not self.is_in_write_group():
 
1208
            raise errors.BzrError("not in write group")
 
1209
        path = self.bzrdir._path_for_remote_call(self._client)
 
1210
        response = self._call('Repository.commit_write_group', path,
 
1211
            self._lock_token, self._write_group_tokens)
 
1212
        if response != ('ok', ):
 
1213
            raise errors.UnexpectedSmartServerResponse(response)
 
1214
        self._write_group_tokens = None
 
1215
        # Refresh data after writing to the repository.
 
1216
        self.refresh_data()
746
1217
 
747
1218
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
 
1219
        if self._real_repository:
 
1220
            return self._real_repository.resume_write_group(tokens)
 
1221
        path = self.bzrdir._path_for_remote_call(self._client)
 
1222
        try:
 
1223
            response = self._call('Repository.check_write_group', path,
 
1224
               self._lock_token, tokens)
 
1225
        except errors.UnknownSmartMethod:
 
1226
            self._ensure_real()
 
1227
            return self._real_repository.resume_write_group(tokens)
 
1228
        if response != ('ok', ):
 
1229
            raise errors.UnexpectedSmartServerResponse(response)
 
1230
        self._write_group_tokens = tokens
750
1231
 
751
1232
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
 
1233
        if self._real_repository:
 
1234
            return self._real_repository.suspend_write_group()
 
1235
        ret = self._write_group_tokens or []
 
1236
        self._write_group_tokens = None
 
1237
        return ret
754
1238
 
755
1239
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
1240
        self._ensure_real()
817
1301
    def find_text_key_references(self):
818
1302
        """Find the text key references within the repository.
819
1303
 
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
1304
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1305
            to whether they were referred to by the inventory of the
825
1306
            revision_id that they contain. The inventory texts from all present
843
1324
        """Private method for using with old (< 1.2) servers to fallback."""
844
1325
        if revision_id is None:
845
1326
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1327
        elif _mod_revision.is_null(revision_id):
847
1328
            return {}
848
1329
 
849
1330
        path = self.bzrdir._path_for_remote_call(self._client)
873
1354
        return RemoteStreamSource(self, to_format)
874
1355
 
875
1356
    @needs_read_lock
 
1357
    def get_file_graph(self):
 
1358
        return graph.Graph(self.texts)
 
1359
 
 
1360
    @needs_read_lock
876
1361
    def has_revision(self, revision_id):
877
1362
        """True if this repository has a copy of the revision."""
878
1363
        # Copy of bzrlib.repository.Repository.has_revision
895
1380
    def _has_same_fallbacks(self, other_repo):
896
1381
        """Returns true if the repositories have the same fallbacks."""
897
1382
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1383
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1384
        my_fb = self._fallback_repositories
900
1385
        other_fb = other_repo._fallback_repositories
901
1386
        if len(my_fb) != len(other_fb):
930
1415
        """See Repository.gather_stats()."""
931
1416
        path = self.bzrdir._path_for_remote_call(self._client)
932
1417
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1418
        if revid is None or _mod_revision.is_null(revid):
934
1419
            fmt_revid = ''
935
1420
        else:
936
1421
            fmt_revid = revid
965
1450
 
966
1451
    def get_physical_lock_status(self):
967
1452
        """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()
 
1453
        path = self.bzrdir._path_for_remote_call(self._client)
 
1454
        try:
 
1455
            response = self._call('Repository.get_physical_lock_status', path)
 
1456
        except errors.UnknownSmartMethod:
 
1457
            self._ensure_real()
 
1458
            return self._real_repository.get_physical_lock_status()
 
1459
        if response[0] not in ('yes', 'no'):
 
1460
            raise errors.UnexpectedSmartServerResponse(response)
 
1461
        return (response[0] == 'yes')
971
1462
 
972
1463
    def is_in_write_group(self):
973
1464
        """Return True if there is an open write group.
974
1465
 
975
1466
        write groups are only applicable locally for the smart server..
976
1467
        """
 
1468
        if self._write_group_tokens is not None:
 
1469
            return True
977
1470
        if self._real_repository:
978
1471
            return self._real_repository.is_in_write_group()
979
1472
 
997
1490
        pass
998
1491
 
999
1492
    def lock_read(self):
 
1493
        """Lock the repository for read operations.
 
1494
 
 
1495
        :return: A bzrlib.lock.LogicalLockResult.
 
1496
        """
1000
1497
        # wrong eventually - want a local lock cache context
1001
1498
        if not self._lock_mode:
1002
1499
            self._note_lock('r')
1009
1506
                repo.lock_read()
1010
1507
        else:
1011
1508
            self._lock_count += 1
 
1509
        return lock.LogicalLockResult(self.unlock)
1012
1510
 
1013
1511
    def _remote_lock_write(self, token):
1014
1512
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1552
            raise errors.ReadOnlyError(self)
1055
1553
        else:
1056
1554
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1555
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1556
 
1059
1557
    def leave_lock_in_place(self):
1060
1558
        if not self._lock_token:
1109
1607
            self._real_repository.lock_write(self._lock_token)
1110
1608
        elif self._lock_mode == 'r':
1111
1609
            self._real_repository.lock_read()
 
1610
        if self._write_group_tokens is not None:
 
1611
            # if we are already in a write group, resume it
 
1612
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1613
            self._write_group_tokens = None
1112
1614
 
1113
1615
    def start_write_group(self):
1114
1616
        """Start a write group on the decorated repository.
1118
1620
        for older plugins that don't use e.g. the CommitBuilder
1119
1621
        facility.
1120
1622
        """
1121
 
        self._ensure_real()
1122
 
        return self._real_repository.start_write_group()
 
1623
        if self._real_repository:
 
1624
            self._ensure_real()
 
1625
            return self._real_repository.start_write_group()
 
1626
        if not self.is_write_locked():
 
1627
            raise errors.NotWriteLocked(self)
 
1628
        if self._write_group_tokens is not None:
 
1629
            raise errors.BzrError('already in a write group')
 
1630
        path = self.bzrdir._path_for_remote_call(self._client)
 
1631
        try:
 
1632
            response = self._call('Repository.start_write_group', path,
 
1633
                self._lock_token)
 
1634
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1635
            self._ensure_real()
 
1636
            return self._real_repository.start_write_group()
 
1637
        if response[0] != 'ok':
 
1638
            raise errors.UnexpectedSmartServerResponse(response)
 
1639
        self._write_group_tokens = response[1]
1123
1640
 
1124
1641
    def _unlock(self, token):
1125
1642
        path = self.bzrdir._path_for_remote_call(self._client)
1152
1669
            # This is just to let the _real_repository stay up to date.
1153
1670
            if self._real_repository is not None:
1154
1671
                self._real_repository.unlock()
 
1672
            elif self._write_group_tokens is not None:
 
1673
                self.abort_write_group()
1155
1674
        finally:
1156
1675
            # The rpc-level lock should be released even if there was a
1157
1676
            # problem releasing the vfs-based lock.
1169
1688
 
1170
1689
    def break_lock(self):
1171
1690
        # should hand off to the network
1172
 
        self._ensure_real()
1173
 
        return self._real_repository.break_lock()
 
1691
        path = self.bzrdir._path_for_remote_call(self._client)
 
1692
        try:
 
1693
            response = self._call("Repository.break_lock", path)
 
1694
        except errors.UnknownSmartMethod:
 
1695
            self._ensure_real()
 
1696
            return self._real_repository.break_lock()
 
1697
        if response != ('ok',):
 
1698
            raise errors.UnexpectedSmartServerResponse(response)
1174
1699
 
1175
1700
    def _get_tarball(self, compression):
1176
1701
        """Return a TemporaryFile containing a repository tarball.
1194
1719
            return t
1195
1720
        raise errors.UnexpectedSmartServerResponse(response)
1196
1721
 
 
1722
    @needs_read_lock
1197
1723
    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)
 
1724
        """Create a descendent repository for new development.
 
1725
 
 
1726
        Unlike clone, this does not copy the settings of the repository.
 
1727
        """
 
1728
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1729
        dest_repo.fetch(self, revision_id=revision_id)
1203
1730
        return dest_repo
1204
1731
 
 
1732
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1733
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1734
            # use target default format.
 
1735
            dest_repo = a_bzrdir.create_repository()
 
1736
        else:
 
1737
            # Most control formats need the repository to be specifically
 
1738
            # created, but on some old all-in-one formats it's not needed
 
1739
            try:
 
1740
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1741
            except errors.UninitializableFormat:
 
1742
                dest_repo = a_bzrdir.open_repository()
 
1743
        return dest_repo
 
1744
 
1205
1745
    ### These methods are just thin shims to the VFS object for now.
1206
1746
 
 
1747
    @needs_read_lock
1207
1748
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1749
        revision_id = _mod_revision.ensure_null(revision_id)
 
1750
        if revision_id == _mod_revision.NULL_REVISION:
 
1751
            return InventoryRevisionTree(self,
 
1752
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1753
        else:
 
1754
            return list(self.revision_trees([revision_id]))[0]
1210
1755
 
1211
1756
    def get_serializer_format(self):
1212
 
        self._ensure_real()
1213
 
        return self._real_repository.get_serializer_format()
 
1757
        path = self.bzrdir._path_for_remote_call(self._client)
 
1758
        try:
 
1759
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1760
                path)
 
1761
        except errors.UnknownSmartMethod:
 
1762
            self._ensure_real()
 
1763
            return self._real_repository.get_serializer_format()
 
1764
        if response[0] != 'ok':
 
1765
            raise errors.UnexpectedSmartServerResponse(response)
 
1766
        return response[1]
1214
1767
 
1215
1768
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1769
                           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
 
1770
                           revision_id=None, lossy=False):
 
1771
        """Obtain a CommitBuilder for this repository.
 
1772
 
 
1773
        :param branch: Branch to commit to.
 
1774
        :param parents: Revision ids of the parents of the new revision.
 
1775
        :param config: Configuration to use.
 
1776
        :param timestamp: Optional timestamp recorded for commit.
 
1777
        :param timezone: Optional timezone for timestamp.
 
1778
        :param committer: Optional committer to set for commit.
 
1779
        :param revprops: Optional dictionary of revision properties.
 
1780
        :param revision_id: Optional revision id.
 
1781
        :param lossy: Whether to discard data that can not be natively
 
1782
            represented, when pushing to a foreign VCS
 
1783
        """
 
1784
        if self._fallback_repositories and not self._format.supports_chks:
 
1785
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1786
                " in pre-2a formats. See "
 
1787
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1788
        if self._format.rich_root_data:
 
1789
            commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
 
1790
        else:
 
1791
            commit_builder_kls = vf_repository.VersionedFileCommitBuilder
 
1792
        result = commit_builder_kls(self, parents, config,
 
1793
            timestamp, timezone, committer, revprops, revision_id,
 
1794
            lossy)
 
1795
        self.start_write_group()
 
1796
        return result
1226
1797
 
1227
1798
    def add_fallback_repository(self, repository):
1228
1799
        """Add a repository to use for looking up data not held locally.
1235
1806
        # We need to accumulate additional repositories here, to pass them in
1236
1807
        # on various RPC's.
1237
1808
        #
 
1809
        # Make the check before we lock: this raises an exception.
 
1810
        self._check_fallback_repository(repository)
1238
1811
        if self.is_locked():
1239
1812
            # We will call fallback.unlock() when we transition to the unlocked
1240
1813
            # state, so always add a lock here. If a caller passes us a locked
1241
1814
            # repository, they are responsible for unlocking it later.
1242
1815
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1816
        self._fallback_repositories.append(repository)
1245
1817
        # If self._real_repository was parameterised already (e.g. because a
1246
1818
        # _real_branch had its get_stacked_on_url method called), then the
1272
1844
            delta, new_revision_id, parents, basis_inv=basis_inv,
1273
1845
            propagate_caches=propagate_caches)
1274
1846
 
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)
 
1847
    def add_revision(self, revision_id, rev, inv=None, config=None):
 
1848
        _mod_revision.check_not_reserved_id(revision_id)
 
1849
        if (config is not None and
 
1850
            config.get('create_signatures') == _mod_config.SIGN_ALWAYS):
 
1851
            if inv is None:
 
1852
                inv = self.get_inventory(revision_id)
 
1853
            tree = InventoryRevisionTree(self, inv, revision_id)
 
1854
            testament = _mod_testament.Testament(rev, tree)
 
1855
            plaintext = testament.as_short_text()
 
1856
            self.store_revision_signature(
 
1857
                gpg.GPGStrategy(config), plaintext, revision_id)
 
1858
        key = (revision_id,)
 
1859
        # check inventory present
 
1860
        if not self.inventories.get_parent_map([key]):
 
1861
            if inv is None:
 
1862
                raise errors.WeaveRevisionNotPresent(revision_id,
 
1863
                                                     self.inventories)
 
1864
            else:
 
1865
                # yes, this is not suitable for adding with ghosts.
 
1866
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
1867
                                                        rev.parent_ids)
 
1868
        else:
 
1869
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
1870
        if self._real_repository is not None:
 
1871
            return self._real_repository.add_revision(
 
1872
                revision_id, rev, inv, config)
 
1873
        text = self._serializer.write_revision_to_string(rev)
 
1874
        parents = tuple((parent,) for parent in rev.parent_ids)
 
1875
        self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
 
1876
            [('revisions', [FulltextContentFactory(key, parents, None, text)])],
 
1877
            self._format, self._write_group_tokens)
1279
1878
 
1280
1879
    @needs_read_lock
1281
1880
    def get_inventory(self, revision_id):
 
1881
        return list(self.iter_inventories([revision_id]))[0]
 
1882
 
 
1883
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1884
        if ordering is None:
 
1885
            ordering = 'unordered'
 
1886
        path = self.bzrdir._path_for_remote_call(self._client)
 
1887
        body = "\n".join(revision_ids)
 
1888
        response_tuple, response_handler = (
 
1889
            self._call_with_body_bytes_expecting_body(
 
1890
                "VersionedFileRepository.get_inventories",
 
1891
                (path, ordering), body))
 
1892
        if response_tuple[0] != "ok":
 
1893
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1894
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1895
        byte_stream = response_handler.read_streamed_body()
 
1896
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1897
        if decoded is None:
 
1898
            # no results whatsoever
 
1899
            return
 
1900
        src_format, stream = decoded
 
1901
        if src_format.network_name() != self._format.network_name():
 
1902
            raise AssertionError(
 
1903
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1904
                src_format.network_name(), self._format.network_name()))
 
1905
        # ignore the src format, it's not really relevant
 
1906
        prev_inv = Inventory(root_id=None,
 
1907
            revision_id=_mod_revision.NULL_REVISION)
 
1908
        # there should be just one substream, with inventory deltas
 
1909
        substream_kind, substream = stream.next()
 
1910
        if substream_kind != "inventory-deltas":
 
1911
            raise AssertionError(
 
1912
                 "Unexpected stream %r received" % substream_kind)
 
1913
        for record in substream:
 
1914
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1915
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1916
            if parent_id != prev_inv.revision_id:
 
1917
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1918
                    prev_inv.revision_id))
 
1919
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1920
            yield inv, inv.revision_id
 
1921
            prev_inv = inv
 
1922
 
 
1923
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
1282
1924
        self._ensure_real()
1283
 
        return self._real_repository.get_inventory(revision_id)
 
1925
        return self._real_repository._iter_inventories(revision_ids, ordering)
1284
1926
 
1285
1927
    def iter_inventories(self, revision_ids, ordering=None):
1286
 
        self._ensure_real()
1287
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1928
        """Get many inventories by revision_ids.
 
1929
 
 
1930
        This will buffer some or all of the texts used in constructing the
 
1931
        inventories in memory, but will only parse a single inventory at a
 
1932
        time.
 
1933
 
 
1934
        :param revision_ids: The expected revision ids of the inventories.
 
1935
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1936
            specified, the order of revision_ids will be preserved (by
 
1937
            buffering if necessary).
 
1938
        :return: An iterator of inventories.
 
1939
        """
 
1940
        if ((None in revision_ids)
 
1941
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1942
            raise ValueError('cannot get null revision inventory')
 
1943
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1944
            if inv is None:
 
1945
                raise errors.NoSuchRevision(self, revid)
 
1946
            yield inv
 
1947
 
 
1948
    def _iter_inventories(self, revision_ids, ordering=None):
 
1949
        if len(revision_ids) == 0:
 
1950
            return
 
1951
        missing = set(revision_ids)
 
1952
        if ordering is None:
 
1953
            order_as_requested = True
 
1954
            invs = {}
 
1955
            order = list(revision_ids)
 
1956
            order.reverse()
 
1957
            next_revid = order.pop()
 
1958
        else:
 
1959
            order_as_requested = False
 
1960
            if ordering != 'unordered' and self._fallback_repositories:
 
1961
                raise ValueError('unsupported ordering %r' % ordering)
 
1962
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
1963
            fallback._iter_inventories for fallback in
 
1964
            self._fallback_repositories]
 
1965
        try:
 
1966
            for iter_inv in iter_inv_fns:
 
1967
                request = [revid for revid in revision_ids if revid in missing]
 
1968
                for inv, revid in iter_inv(request, ordering):
 
1969
                    if inv is None:
 
1970
                        continue
 
1971
                    missing.remove(inv.revision_id)
 
1972
                    if ordering != 'unordered':
 
1973
                        invs[revid] = inv
 
1974
                    else:
 
1975
                        yield inv, revid
 
1976
                if order_as_requested:
 
1977
                    # Yield as many results as we can while preserving order.
 
1978
                    while next_revid in invs:
 
1979
                        inv = invs.pop(next_revid)
 
1980
                        yield inv, inv.revision_id
 
1981
                        try:
 
1982
                            next_revid = order.pop()
 
1983
                        except IndexError:
 
1984
                            # We still want to fully consume the stream, just
 
1985
                            # in case it is not actually finished at this point
 
1986
                            next_revid = None
 
1987
                            break
 
1988
        except errors.UnknownSmartMethod:
 
1989
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
1990
                yield inv, revid
 
1991
            return
 
1992
        # Report missing
 
1993
        if order_as_requested:
 
1994
            if next_revid is not None:
 
1995
                yield None, next_revid
 
1996
            while order:
 
1997
                revid = order.pop()
 
1998
                yield invs.get(revid), revid
 
1999
        else:
 
2000
            while missing:
 
2001
                yield None, missing.pop()
1288
2002
 
1289
2003
    @needs_read_lock
1290
2004
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
2005
        return self.get_revisions([revision_id])[0]
1293
2006
 
1294
2007
    def get_transaction(self):
1295
2008
        self._ensure_real()
1297
2010
 
1298
2011
    @needs_read_lock
1299
2012
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
2013
        dest_repo = self._create_sprouting_repo(
 
2014
            a_bzrdir, shared=self.is_shared())
 
2015
        self.copy_content_into(dest_repo, revision_id)
 
2016
        return dest_repo
1302
2017
 
1303
2018
    def make_working_trees(self):
1304
2019
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
2020
        path = self.bzrdir._path_for_remote_call(self._client)
 
2021
        try:
 
2022
            response = self._call('Repository.make_working_trees', path)
 
2023
        except errors.UnknownSmartMethod:
 
2024
            self._ensure_real()
 
2025
            return self._real_repository.make_working_trees()
 
2026
        if response[0] not in ('yes', 'no'):
 
2027
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2028
        return response[0] == 'yes'
1307
2029
 
1308
2030
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
2031
        """Re-read any data needed to synchronise with disk.
1310
2032
 
1311
2033
        This method is intended to be called after another repository instance
1312
2034
        (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.
 
2035
        repository. On all repositories this will work outside of write groups.
 
2036
        Some repository formats (pack and newer for bzrlib native formats)
 
2037
        support refresh_data inside write groups. If called inside a write
 
2038
        group on a repository that does not support refreshing in a write group
 
2039
        IsInWriteGroupError will be raised.
1315
2040
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
2041
        if self._real_repository is not None:
1320
2042
            self._real_repository.refresh_data()
 
2043
        # Refresh the parents cache for this object
 
2044
        self._unstacked_provider.disable_cache()
 
2045
        self._unstacked_provider.enable_cache()
1321
2046
 
1322
2047
    def revision_ids_to_search_result(self, result_set):
1323
2048
        """Convert a set of revision ids to a graph SearchResult."""
1328
2053
        included_keys = result_set.intersection(result_parents)
1329
2054
        start_keys = result_set.difference(included_keys)
1330
2055
        exclude_keys = result_parents.difference(result_set)
1331
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
2056
        result = vf_search.SearchResult(start_keys, exclude_keys,
1332
2057
            len(result_set), result_set)
1333
2058
        return result
1334
2059
 
1335
2060
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
2061
    def search_missing_revision_ids(self, other,
 
2062
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
2063
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2064
            limit=None):
1337
2065
        """Return the revision ids that other has that this does not.
1338
2066
 
1339
2067
        These are returned in topological order.
1340
2068
 
1341
2069
        revision_id: only return revision ids included by revision_id.
1342
2070
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
2071
        if symbol_versioning.deprecated_passed(revision_id):
 
2072
            symbol_versioning.warn(
 
2073
                'search_missing_revision_ids(revision_id=...) was '
 
2074
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
2075
                DeprecationWarning, stacklevel=2)
 
2076
            if revision_ids is not None:
 
2077
                raise AssertionError(
 
2078
                    'revision_ids is mutually exclusive with revision_id')
 
2079
            if revision_id is not None:
 
2080
                revision_ids = [revision_id]
 
2081
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
2082
        return inter_repo.search_missing_revision_ids(
 
2083
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
2084
            if_present_ids=if_present_ids, limit=limit)
1345
2085
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
2086
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
2087
            fetch_spec=None):
1348
2088
        # No base implementation to use as RemoteRepository is not a subclass
1349
2089
        # of Repository; so this is a copy of Repository.fetch().
1360
2100
            # check that last_revision is in 'from' and then return a
1361
2101
            # no-operation.
1362
2102
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
2103
                not _mod_revision.is_null(revision_id)):
1364
2104
                self.get_revision(revision_id)
1365
2105
            return 0, []
1366
2106
        # if there is no specific appropriate InterRepository, this will get
1367
2107
        # the InterRepository base class, which raises an
1368
2108
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
2109
        inter = _mod_repository.InterRepository.get(source, self)
 
2110
        if (fetch_spec is not None and
 
2111
            not getattr(inter, "supports_fetch_spec", False)):
 
2112
            raise errors.UnsupportedOperation(
 
2113
                "fetch_spec not supported for %r" % inter)
 
2114
        return inter.fetch(revision_id=revision_id,
1371
2115
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
2116
 
1373
2117
    def create_bundle(self, target, base, fileobj, format=None):
1375
2119
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
2120
 
1377
2121
    @needs_read_lock
 
2122
    @symbol_versioning.deprecated_method(
 
2123
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
2124
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
2125
        self._ensure_real()
1380
2126
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1388
2134
        return self._real_repository._get_versioned_file_checker(
1389
2135
            revisions, revision_versions_cache)
1390
2136
 
 
2137
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2138
        path = self.bzrdir._path_for_remote_call(self._client)
 
2139
        lines = []
 
2140
        identifiers = []
 
2141
        for (file_id, revid, identifier) in desired_files:
 
2142
            lines.append("%s\0%s" % (
 
2143
                osutils.safe_file_id(file_id),
 
2144
                osutils.safe_revision_id(revid)))
 
2145
            identifiers.append(identifier)
 
2146
        (response_tuple, response_handler) = (
 
2147
            self._call_with_body_bytes_expecting_body(
 
2148
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2149
        if response_tuple != ('ok', ):
 
2150
            response_handler.cancel_read_body()
 
2151
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2152
        byte_stream = response_handler.read_streamed_body()
 
2153
        def decompress_stream(start, byte_stream, unused):
 
2154
            decompressor = zlib.decompressobj()
 
2155
            yield decompressor.decompress(start)
 
2156
            while decompressor.unused_data == "":
 
2157
                try:
 
2158
                    data = byte_stream.next()
 
2159
                except StopIteration:
 
2160
                    break
 
2161
                yield decompressor.decompress(data)
 
2162
            yield decompressor.flush()
 
2163
            unused.append(decompressor.unused_data)
 
2164
        unused = ""
 
2165
        while True:
 
2166
            while not "\n" in unused:
 
2167
                unused += byte_stream.next()
 
2168
            header, rest = unused.split("\n", 1)
 
2169
            args = header.split("\0")
 
2170
            if args[0] == "absent":
 
2171
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2172
                unused = rest
 
2173
                continue
 
2174
            elif args[0] == "ok":
 
2175
                idx = int(args[1])
 
2176
            else:
 
2177
                raise errors.UnexpectedSmartServerResponse(args)
 
2178
            unused_chunks = []
 
2179
            yield (identifiers[idx],
 
2180
                decompress_stream(rest, byte_stream, unused_chunks))
 
2181
            unused = "".join(unused_chunks)
 
2182
 
1391
2183
    def iter_files_bytes(self, desired_files):
1392
2184
        """See Repository.iter_file_bytes.
1393
2185
        """
1394
 
        self._ensure_real()
1395
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2186
        try:
 
2187
            absent = {}
 
2188
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2189
                    desired_files, absent):
 
2190
                yield identifier, bytes_iterator
 
2191
            for fallback in self._fallback_repositories:
 
2192
                if not absent:
 
2193
                    break
 
2194
                desired_files = [(key[0], key[1], identifier) for
 
2195
                    (identifier, key) in absent.iteritems()]
 
2196
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2197
                    del absent[identifier]
 
2198
                    yield identifier, bytes_iterator
 
2199
            if absent:
 
2200
                # There may be more missing items, but raise an exception
 
2201
                # for just one.
 
2202
                missing_identifier = absent.keys()[0]
 
2203
                missing_key = absent[missing_identifier]
 
2204
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2205
                    file_id=missing_key[0])
 
2206
        except errors.UnknownSmartMethod:
 
2207
            self._ensure_real()
 
2208
            for (identifier, bytes_iterator) in (
 
2209
                self._real_repository.iter_files_bytes(desired_files)):
 
2210
                yield identifier, bytes_iterator
 
2211
 
 
2212
    def get_cached_parent_map(self, revision_ids):
 
2213
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2214
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1396
2215
 
1397
2216
    def get_parent_map(self, revision_ids):
1398
2217
        """See bzrlib.Graph.get_parent_map()."""
1457
2276
        if parents_map is None:
1458
2277
            # Repository is not locked, so there's no cache.
1459
2278
            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)
 
2279
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2280
            (start_set, stop_keys,
 
2281
             key_count) = vf_search.search_result_from_parent_map(
 
2282
                parents_map, self._unstacked_provider.missing_keys)
 
2283
        else:
 
2284
            (start_set, stop_keys,
 
2285
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2286
                parents_map, self._unstacked_provider.missing_keys,
 
2287
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
2288
        recipe = ('manual', start_set, stop_keys, key_count)
1481
2289
        body = self._serialise_search_recipe(recipe)
1482
2290
        path = self.bzrdir._path_for_remote_call(self._client)
1531
2339
 
1532
2340
    @needs_read_lock
1533
2341
    def get_signature_text(self, revision_id):
1534
 
        self._ensure_real()
1535
 
        return self._real_repository.get_signature_text(revision_id)
 
2342
        path = self.bzrdir._path_for_remote_call(self._client)
 
2343
        try:
 
2344
            response_tuple, response_handler = self._call_expecting_body(
 
2345
                'Repository.get_revision_signature_text', path, revision_id)
 
2346
        except errors.UnknownSmartMethod:
 
2347
            self._ensure_real()
 
2348
            return self._real_repository.get_signature_text(revision_id)
 
2349
        except errors.NoSuchRevision, err:
 
2350
            for fallback in self._fallback_repositories:
 
2351
                try:
 
2352
                    return fallback.get_signature_text(revision_id)
 
2353
                except errors.NoSuchRevision:
 
2354
                    pass
 
2355
            raise err
 
2356
        else:
 
2357
            if response_tuple[0] != 'ok':
 
2358
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2359
            return response_handler.read_body_bytes()
1536
2360
 
1537
2361
    @needs_read_lock
1538
2362
    def _get_inventory_xml(self, revision_id):
 
2363
        # This call is used by older working tree formats,
 
2364
        # which stored a serialized basis inventory.
1539
2365
        self._ensure_real()
1540
2366
        return self._real_repository._get_inventory_xml(revision_id)
1541
2367
 
 
2368
    @needs_write_lock
1542
2369
    def reconcile(self, other=None, thorough=False):
1543
 
        self._ensure_real()
1544
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2370
        from bzrlib.reconcile import RepoReconciler
 
2371
        path = self.bzrdir._path_for_remote_call(self._client)
 
2372
        try:
 
2373
            response, handler = self._call_expecting_body(
 
2374
                'Repository.reconcile', path, self._lock_token)
 
2375
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2376
            self._ensure_real()
 
2377
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2378
        if response != ('ok', ):
 
2379
            raise errors.UnexpectedSmartServerResponse(response)
 
2380
        body = handler.read_body_bytes()
 
2381
        result = RepoReconciler(self)
 
2382
        for line in body.split('\n'):
 
2383
            if not line:
 
2384
                continue
 
2385
            key, val_text = line.split(':')
 
2386
            if key == "garbage_inventories":
 
2387
                result.garbage_inventories = int(val_text)
 
2388
            elif key == "inconsistent_parents":
 
2389
                result.inconsistent_parents = int(val_text)
 
2390
            else:
 
2391
                mutter("unknown reconcile key %r" % key)
 
2392
        return result
1545
2393
 
1546
2394
    def all_revision_ids(self):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.all_revision_ids()
 
2395
        path = self.bzrdir._path_for_remote_call(self._client)
 
2396
        try:
 
2397
            response_tuple, response_handler = self._call_expecting_body(
 
2398
                "Repository.all_revision_ids", path)
 
2399
        except errors.UnknownSmartMethod:
 
2400
            self._ensure_real()
 
2401
            return self._real_repository.all_revision_ids()
 
2402
        if response_tuple != ("ok", ):
 
2403
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2404
        revids = set(response_handler.read_body_bytes().splitlines())
 
2405
        for fallback in self._fallback_repositories:
 
2406
            revids.update(set(fallback.all_revision_ids()))
 
2407
        return list(revids)
 
2408
 
 
2409
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2410
        """Return Tree for a revision on this branch with only some files.
 
2411
 
 
2412
        :param revision_ids: a sequence of revision-ids;
 
2413
          a revision-id may not be None or 'null:'
 
2414
        :param file_ids: if not None, the result is filtered
 
2415
          so that only those file-ids, their parents and their
 
2416
          children are included.
 
2417
        """
 
2418
        inventories = self.iter_inventories(revision_ids)
 
2419
        for inv in inventories:
 
2420
            # Should we introduce a FilteredRevisionTree class rather
 
2421
            # than pre-filter the inventory here?
 
2422
            filtered_inv = inv.filter(file_ids)
 
2423
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1549
2424
 
1550
2425
    @needs_read_lock
1551
2426
    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)
 
2427
        medium = self._client._medium
 
2428
        if medium._is_remote_before((1, 2)):
 
2429
            self._ensure_real()
 
2430
            for delta in self._real_repository.get_deltas_for_revisions(
 
2431
                    revisions, specific_fileids):
 
2432
                yield delta
 
2433
            return
 
2434
        # Get the revision-ids of interest
 
2435
        required_trees = set()
 
2436
        for revision in revisions:
 
2437
            required_trees.add(revision.revision_id)
 
2438
            required_trees.update(revision.parent_ids[:1])
 
2439
 
 
2440
        # Get the matching filtered trees. Note that it's more
 
2441
        # efficient to pass filtered trees to changes_from() rather
 
2442
        # than doing the filtering afterwards. changes_from() could
 
2443
        # arguably do the filtering itself but it's path-based, not
 
2444
        # file-id based, so filtering before or afterwards is
 
2445
        # currently easier.
 
2446
        if specific_fileids is None:
 
2447
            trees = dict((t.get_revision_id(), t) for
 
2448
                t in self.revision_trees(required_trees))
 
2449
        else:
 
2450
            trees = dict((t.get_revision_id(), t) for
 
2451
                t in self._filtered_revision_trees(required_trees,
 
2452
                specific_fileids))
 
2453
 
 
2454
        # Calculate the deltas
 
2455
        for revision in revisions:
 
2456
            if not revision.parent_ids:
 
2457
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2458
            else:
 
2459
                old_tree = trees[revision.parent_ids[0]]
 
2460
            yield trees[revision.revision_id].changes_from(old_tree)
1555
2461
 
1556
2462
    @needs_read_lock
1557
2463
    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)
 
2464
        r = self.get_revision(revision_id)
 
2465
        return list(self.get_deltas_for_revisions([r],
 
2466
            specific_fileids=specific_fileids))[0]
1561
2467
 
1562
2468
    @needs_read_lock
1563
2469
    def revision_trees(self, revision_ids):
1564
 
        self._ensure_real()
1565
 
        return self._real_repository.revision_trees(revision_ids)
 
2470
        inventories = self.iter_inventories(revision_ids)
 
2471
        for inv in inventories:
 
2472
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1566
2473
 
1567
2474
    @needs_read_lock
1568
2475
    def get_revision_reconcile(self, revision_id):
1576
2483
            callback_refs=callback_refs, check_repo=check_repo)
1577
2484
 
1578
2485
    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)
 
2486
        """Make a complete copy of the content in self into destination.
 
2487
 
 
2488
        This is a destructive operation! Do not use it on existing
 
2489
        repositories.
 
2490
        """
 
2491
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2492
        return interrepo.copy_content(revision_id)
1582
2493
 
1583
2494
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2495
        # get a tarball of the remote repository, and copy from that into the
1585
2496
        # destination
1586
 
        from bzrlib import osutils
1587
2497
        import tarfile
1588
2498
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2499
        note(gettext("Copying repository content as tarball..."))
1590
2500
        tar_file = self._get_tarball('bz2')
1591
2501
        if tar_file is None:
1592
2502
            return None
1597
2507
            tmpdir = osutils.mkdtemp()
1598
2508
            try:
1599
2509
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2510
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2511
                tmp_repo = tmp_bzrdir.open_repository()
1602
2512
                tmp_repo.copy_content_into(destination, revision_id)
1603
2513
            finally:
1621
2531
    @needs_write_lock
1622
2532
    def pack(self, hint=None, clean_obsolete_packs=False):
1623
2533
        """Compress the data within the repository.
1624
 
 
1625
 
        This is not currently implemented within the smart server.
1626
2534
        """
1627
 
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2535
        if hint is None:
 
2536
            body = ""
 
2537
        else:
 
2538
            body = "".join([l+"\n" for l in hint])
 
2539
        path = self.bzrdir._path_for_remote_call(self._client)
 
2540
        try:
 
2541
            response, handler = self._call_with_body_bytes_expecting_body(
 
2542
                'Repository.pack', (path, self._lock_token,
 
2543
                    str(clean_obsolete_packs)), body)
 
2544
        except errors.UnknownSmartMethod:
 
2545
            self._ensure_real()
 
2546
            return self._real_repository.pack(hint=hint,
 
2547
                clean_obsolete_packs=clean_obsolete_packs)
 
2548
        handler.cancel_read_body()
 
2549
        if response != ('ok', ):
 
2550
            raise errors.UnexpectedSmartServerResponse(response)
1629
2551
 
1630
2552
    @property
1631
2553
    def revisions(self):
1632
2554
        """Decorate the real repository for now.
1633
2555
 
1634
 
        In the short term this should become a real object to intercept graph
1635
 
        lookups.
1636
 
 
1637
2556
        In the long term a full blown network facility is needed.
1638
2557
        """
1639
2558
        self._ensure_real()
1667
2586
 
1668
2587
    @needs_write_lock
1669
2588
    def sign_revision(self, revision_id, gpg_strategy):
1670
 
        self._ensure_real()
1671
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2589
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2590
        plaintext = testament.as_short_text()
 
2591
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1672
2592
 
1673
2593
    @property
1674
2594
    def texts(self):
1680
2600
        self._ensure_real()
1681
2601
        return self._real_repository.texts
1682
2602
 
 
2603
    def _iter_revisions_rpc(self, revision_ids):
 
2604
        body = "\n".join(revision_ids)
 
2605
        path = self.bzrdir._path_for_remote_call(self._client)
 
2606
        response_tuple, response_handler = (
 
2607
            self._call_with_body_bytes_expecting_body(
 
2608
            "Repository.iter_revisions", (path, ), body))
 
2609
        if response_tuple[0] != "ok":
 
2610
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2611
        serializer_format = response_tuple[1]
 
2612
        serializer = serializer_format_registry.get(serializer_format)
 
2613
        byte_stream = response_handler.read_streamed_body()
 
2614
        decompressor = zlib.decompressobj()
 
2615
        chunks = []
 
2616
        for bytes in byte_stream:
 
2617
            chunks.append(decompressor.decompress(bytes))
 
2618
            if decompressor.unused_data != "":
 
2619
                chunks.append(decompressor.flush())
 
2620
                yield serializer.read_revision_from_string("".join(chunks))
 
2621
                unused = decompressor.unused_data
 
2622
                decompressor = zlib.decompressobj()
 
2623
                chunks = [decompressor.decompress(unused)]
 
2624
        chunks.append(decompressor.flush())
 
2625
        text = "".join(chunks)
 
2626
        if text != "":
 
2627
            yield serializer.read_revision_from_string("".join(chunks))
 
2628
 
1683
2629
    @needs_read_lock
1684
2630
    def get_revisions(self, revision_ids):
1685
 
        self._ensure_real()
1686
 
        return self._real_repository.get_revisions(revision_ids)
 
2631
        if revision_ids is None:
 
2632
            revision_ids = self.all_revision_ids()
 
2633
        else:
 
2634
            for rev_id in revision_ids:
 
2635
                if not rev_id or not isinstance(rev_id, basestring):
 
2636
                    raise errors.InvalidRevisionId(
 
2637
                        revision_id=rev_id, branch=self)
 
2638
        try:
 
2639
            missing = set(revision_ids)
 
2640
            revs = {}
 
2641
            for rev in self._iter_revisions_rpc(revision_ids):
 
2642
                missing.remove(rev.revision_id)
 
2643
                revs[rev.revision_id] = rev
 
2644
        except errors.UnknownSmartMethod:
 
2645
            self._ensure_real()
 
2646
            return self._real_repository.get_revisions(revision_ids)
 
2647
        for fallback in self._fallback_repositories:
 
2648
            if not missing:
 
2649
                break
 
2650
            for revid in list(missing):
 
2651
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2652
                # public method on Repository that could be used to query
 
2653
                # for revision objects *without* failing completely if one
 
2654
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2655
                # but unfortunately that's private and not provided by
 
2656
                # all repository implementations.
 
2657
                try:
 
2658
                    revs[revid] = fallback.get_revision(revid)
 
2659
                except errors.NoSuchRevision:
 
2660
                    pass
 
2661
                else:
 
2662
                    missing.remove(revid)
 
2663
        if missing:
 
2664
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2665
        return [revs[revid] for revid in revision_ids]
1687
2666
 
1688
2667
    def supports_rich_root(self):
1689
2668
        return self._format.rich_root_data
1690
2669
 
 
2670
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2671
    def iter_reverse_revision_history(self, revision_id):
1692
2672
        self._ensure_real()
1693
2673
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2676
    def _serializer(self):
1697
2677
        return self._format._serializer
1698
2678
 
 
2679
    @needs_write_lock
1699
2680
    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)
 
2681
        signature = gpg_strategy.sign(plaintext)
 
2682
        self.add_signature_text(revision_id, signature)
1703
2683
 
1704
2684
    def add_signature_text(self, revision_id, signature):
1705
 
        self._ensure_real()
1706
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2685
        if self._real_repository:
 
2686
            # If there is a real repository the write group will
 
2687
            # be in the real repository as well, so use that:
 
2688
            self._ensure_real()
 
2689
            return self._real_repository.add_signature_text(
 
2690
                revision_id, signature)
 
2691
        path = self.bzrdir._path_for_remote_call(self._client)
 
2692
        response, handler = self._call_with_body_bytes_expecting_body(
 
2693
            'Repository.add_signature_text', (path, self._lock_token,
 
2694
                revision_id) + tuple(self._write_group_tokens), signature)
 
2695
        handler.cancel_read_body()
 
2696
        self.refresh_data()
 
2697
        if response[0] != 'ok':
 
2698
            raise errors.UnexpectedSmartServerResponse(response)
 
2699
        self._write_group_tokens = response[1:]
1707
2700
 
1708
2701
    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)
 
2702
        path = self.bzrdir._path_for_remote_call(self._client)
 
2703
        try:
 
2704
            response = self._call('Repository.has_signature_for_revision_id',
 
2705
                path, revision_id)
 
2706
        except errors.UnknownSmartMethod:
 
2707
            self._ensure_real()
 
2708
            return self._real_repository.has_signature_for_revision_id(
 
2709
                revision_id)
 
2710
        if response[0] not in ('yes', 'no'):
 
2711
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2712
        if response[0] == 'yes':
 
2713
            return True
 
2714
        for fallback in self._fallback_repositories:
 
2715
            if fallback.has_signature_for_revision_id(revision_id):
 
2716
                return True
 
2717
        return False
 
2718
 
 
2719
    @needs_read_lock
 
2720
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2721
        if not self.has_signature_for_revision_id(revision_id):
 
2722
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2723
        signature = self.get_signature_text(revision_id)
 
2724
 
 
2725
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2726
        plaintext = testament.as_short_text()
 
2727
 
 
2728
        return gpg_strategy.verify(signature, plaintext)
1711
2729
 
1712
2730
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2731
        self._ensure_real()
1714
2732
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2733
            _files_pb=_files_pb)
1716
2734
 
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
2735
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2736
        self._ensure_real()
1724
2737
        return self._real_repository._find_inconsistent_revision_parents(
1732
2745
        providers = [self._unstacked_provider]
1733
2746
        if other is not None:
1734
2747
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2748
        return graph.StackedParentsProvider(_LazyListJoin(
 
2749
            providers, self._fallback_repositories))
1738
2750
 
1739
2751
    def _serialise_search_recipe(self, recipe):
1740
2752
        """Serialise a graph search recipe.
1748
2760
        return '\n'.join((start_keys, stop_keys, count))
1749
2761
 
1750
2762
    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)]
 
2763
        parts = search_result.get_network_struct()
1757
2764
        return '\n'.join(parts)
1758
2765
 
1759
2766
    def autopack(self):
1769
2776
            raise errors.UnexpectedSmartServerResponse(response)
1770
2777
 
1771
2778
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2779
class RemoteStreamSink(vf_repository.StreamSink):
1773
2780
 
1774
2781
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2782
        self.target_repo._ensure_real()
1876
2883
        self._last_substream and self._last_stream so that the stream can be
1877
2884
        resumed by _resume_stream_with_vfs.
1878
2885
        """
1879
 
                    
 
2886
 
1880
2887
        stream_iter = iter(stream)
1881
2888
        for substream_kind, substream in stream_iter:
1882
2889
            if substream_kind == 'inventory-deltas':
1885
2892
                return
1886
2893
            else:
1887
2894
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2895
 
 
2896
 
 
2897
class RemoteStreamSource(vf_repository.StreamSource):
1891
2898
    """Stream data from a remote server."""
1892
2899
 
1893
2900
    def get_stream(self, search):
1914
2921
 
1915
2922
    def _real_stream(self, repo, search):
1916
2923
        """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 
 
2924
 
 
2925
        This never called RemoteStreamSource.get_stream, and is a helper
 
2926
        for RemoteStreamSource._get_stream to allow getting a stream
1920
2927
        reliably whether fallback back because of old servers or trying
1921
2928
        to stream from a non-RemoteRepository (which the stacked support
1922
2929
        code will do).
1953
2960
        candidate_verbs = [
1954
2961
            ('Repository.get_stream_1.19', (1, 19)),
1955
2962
            ('Repository.get_stream', (1, 13))]
 
2963
 
1956
2964
        found_verb = False
1957
2965
        for verb, version in candidate_verbs:
1958
2966
            if medium._is_remote_before(version):
1962
2970
                    verb, args, search_bytes)
1963
2971
            except errors.UnknownSmartMethod:
1964
2972
                medium._remember_remote_is_before(version)
 
2973
            except errors.UnknownErrorFromSmartServer, e:
 
2974
                if isinstance(search, vf_search.EverythingResult):
 
2975
                    error_verb = e.error_from_smart_server.error_verb
 
2976
                    if error_verb == 'BadSearch':
 
2977
                        # Pre-2.4 servers don't support this sort of search.
 
2978
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2979
                        # good idea in general?  It might provide a little bit
 
2980
                        # of protection against client-side bugs.
 
2981
                        medium._remember_remote_is_before((2, 4))
 
2982
                        break
 
2983
                raise
1965
2984
            else:
1966
2985
                response_tuple, response_handler = response
1967
2986
                found_verb = True
1971
2990
        if response_tuple[0] != 'ok':
1972
2991
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2992
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2993
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2994
            self._record_counter)
1975
2995
        if src_format.network_name() != repo._format.network_name():
1976
2996
            raise AssertionError(
1977
2997
                "Mismatched RemoteRepository and stream src %r, %r" % (
2049
3069
 
2050
3070
    def _ensure_real(self):
2051
3071
        if self._custom_format is None:
2052
 
            self._custom_format = branch.network_format_registry.get(
2053
 
                self._network_name)
 
3072
            try:
 
3073
                self._custom_format = branch.network_format_registry.get(
 
3074
                    self._network_name)
 
3075
            except KeyError:
 
3076
                raise errors.UnknownFormatError(kind='branch',
 
3077
                    format=self._network_name)
2054
3078
 
2055
3079
    def get_format_description(self):
2056
3080
        self._ensure_real()
2063
3087
        return a_bzrdir.open_branch(name=name, 
2064
3088
            ignore_fallbacks=ignore_fallbacks)
2065
3089
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
3090
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
3091
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
3092
        # method is not available on the server.
2069
3093
        # self._custom_format is always set - the start of initialize ensures
2071
3095
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
3096
            a_bzrdir._ensure_real()
2073
3097
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
3098
                name, append_revisions_only=append_revisions_only)
2075
3099
        else:
2076
3100
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
3101
            result = self._custom_format.initialize(a_bzrdir, name,
 
3102
                append_revisions_only=append_revisions_only)
2078
3103
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
3104
            not isinstance(result, RemoteBranch)):
2080
3105
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
3106
                                  name=name)
2082
3107
        return result
2083
3108
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
3109
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3110
                   append_revisions_only=None):
2085
3111
        # 1) get the network name to use.
2086
3112
        if self._custom_format:
2087
3113
            network_name = self._custom_format.network_name()
2088
3114
        else:
2089
3115
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
3116
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
3117
            reference_format = reference_bzrdir_format.get_branch_format()
2092
3118
            self._custom_format = reference_format
2093
3119
            network_name = reference_format.network_name()
2094
3120
        # Being asked to create on a non RemoteBzrDir:
2095
3121
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3122
            return self._vfs_initialize(a_bzrdir, name=name,
 
3123
                append_revisions_only=append_revisions_only)
2097
3124
        medium = a_bzrdir._client._medium
2098
3125
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3126
            return self._vfs_initialize(a_bzrdir, name=name,
 
3127
                append_revisions_only=append_revisions_only)
2100
3128
        # Creating on a remote bzr dir.
2101
3129
        # 2) try direct creation via RPC
2102
3130
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
3137
        except errors.UnknownSmartMethod:
2110
3138
            # Fallback - use vfs methods
2111
3139
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
3140
            return self._vfs_initialize(a_bzrdir, name=name,
 
3141
                    append_revisions_only=append_revisions_only)
2113
3142
        if response[0] != 'ok':
2114
3143
            raise errors.UnexpectedSmartServerResponse(response)
2115
3144
        # Turn the response into a RemoteRepository object.
2116
3145
        format = RemoteBranchFormat(network_name=response[1])
2117
3146
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
3147
        repo_path = response[2]
 
3148
        if repository is not None:
 
3149
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
3150
            url_diff = urlutils.relative_url(repository.user_url,
 
3151
                    remote_repo_url)
 
3152
            if url_diff != '.':
 
3153
                raise AssertionError(
 
3154
                    'repository.user_url %r does not match URL from server '
 
3155
                    'response (%r + %r)'
 
3156
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
3157
            remote_repo = repository
2120
3158
        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)
 
3159
            if repo_path == '':
 
3160
                repo_bzrdir = a_bzrdir
 
3161
            else:
 
3162
                repo_bzrdir = RemoteBzrDir(
 
3163
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
3164
                    a_bzrdir._client)
 
3165
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
3166
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
3167
            format=format, setup_stacking=False, name=name)
 
3168
        if append_revisions_only:
 
3169
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
3170
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
3171
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
3172
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
3191
        self._ensure_real()
2149
3192
        return self._custom_format.supports_set_append_revisions_only()
2150
3193
 
 
3194
    def _use_default_local_heads_to_fetch(self):
 
3195
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3196
        # implementation is not overridden vs the base class, we can use the
 
3197
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3198
        # usually cheaper in terms of net round trips, as the last-revision and
 
3199
        # tags info fetched is cached and would be fetched anyway.
 
3200
        self._ensure_real()
 
3201
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3202
            branch_class = self._custom_format._branch_class()
 
3203
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3204
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3205
                return True
 
3206
        return False
 
3207
 
 
3208
 
 
3209
class RemoteBranchStore(_mod_config.IniFileStore):
 
3210
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3211
 
 
3212
    Note that this is specific to bzr-based formats.
 
3213
    """
 
3214
 
 
3215
    def __init__(self, branch):
 
3216
        super(RemoteBranchStore, self).__init__()
 
3217
        self.branch = branch
 
3218
        self.id = "branch"
 
3219
        self._real_store = None
 
3220
 
 
3221
    def lock_write(self, token=None):
 
3222
        return self.branch.lock_write(token)
 
3223
 
 
3224
    def unlock(self):
 
3225
        return self.branch.unlock()
 
3226
 
 
3227
    @needs_write_lock
 
3228
    def save(self):
 
3229
        # We need to be able to override the undecorated implementation
 
3230
        self.save_without_locking()
 
3231
 
 
3232
    def save_without_locking(self):
 
3233
        super(RemoteBranchStore, self).save()
 
3234
 
 
3235
    def external_url(self):
 
3236
        return self.branch.user_url
 
3237
 
 
3238
    def _load_content(self):
 
3239
        path = self.branch._remote_path()
 
3240
        try:
 
3241
            response, handler = self.branch._call_expecting_body(
 
3242
                'Branch.get_config_file', path)
 
3243
        except errors.UnknownSmartMethod:
 
3244
            self._ensure_real()
 
3245
            return self._real_store._load_content()
 
3246
        if len(response) and response[0] != 'ok':
 
3247
            raise errors.UnexpectedSmartServerResponse(response)
 
3248
        return handler.read_body_bytes()
 
3249
 
 
3250
    def _save_content(self, content):
 
3251
        path = self.branch._remote_path()
 
3252
        try:
 
3253
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3254
                'Branch.put_config_file', (path,
 
3255
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3256
                content)
 
3257
        except errors.UnknownSmartMethod:
 
3258
            self._ensure_real()
 
3259
            return self._real_store._save_content(content)
 
3260
        handler.cancel_read_body()
 
3261
        if response != ('ok', ):
 
3262
            raise errors.UnexpectedSmartServerResponse(response)
 
3263
 
 
3264
    def _ensure_real(self):
 
3265
        self.branch._ensure_real()
 
3266
        if self._real_store is None:
 
3267
            self._real_store = _mod_config.BranchStore(self.branch)
 
3268
 
2151
3269
 
2152
3270
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
3271
    """Branch stored on a server accessed by HPSS RPC.
2156
3274
    """
2157
3275
 
2158
3276
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3277
        _client=None, format=None, setup_stacking=True, name=None,
 
3278
        possible_transports=None):
2160
3279
        """Create a RemoteBranch instance.
2161
3280
 
2162
3281
        :param real_branch: An optional local implementation of the branch
2227
3346
            hook(self)
2228
3347
        self._is_stacked = False
2229
3348
        if setup_stacking:
2230
 
            self._setup_stacking()
 
3349
            self._setup_stacking(possible_transports)
2231
3350
 
2232
 
    def _setup_stacking(self):
 
3351
    def _setup_stacking(self, possible_transports):
2233
3352
        # configure stacking into the remote repository, by reading it from
2234
3353
        # the vfs branch.
2235
3354
        try:
2238
3357
            errors.UnstackableRepositoryFormat), e:
2239
3358
            return
2240
3359
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
 
3360
        if possible_transports is None:
 
3361
            possible_transports = []
 
3362
        else:
 
3363
            possible_transports = list(possible_transports)
 
3364
        possible_transports.append(self.bzrdir.root_transport)
 
3365
        self._activate_fallback_location(fallback_url,
 
3366
            possible_transports=possible_transports)
2242
3367
 
2243
3368
    def _get_config(self):
2244
3369
        return RemoteBranchConfig(self)
2245
3370
 
 
3371
    def _get_config_store(self):
 
3372
        return RemoteBranchStore(self)
 
3373
 
2246
3374
    def _get_real_transport(self):
2247
3375
        # if we try vfs access, return the real branch's vfs transport
2248
3376
        self._ensure_real()
2311
3439
                self.bzrdir, self._client)
2312
3440
        return self._control_files
2313
3441
 
2314
 
    def _get_checkout_format(self):
2315
 
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
2317
 
 
2318
3442
    def get_physical_lock_status(self):
2319
3443
        """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()
 
3444
        try:
 
3445
            response = self._client.call('Branch.get_physical_lock_status',
 
3446
                self._remote_path())
 
3447
        except errors.UnknownSmartMethod:
 
3448
            self._ensure_real()
 
3449
            return self._real_branch.get_physical_lock_status()
 
3450
        if response[0] not in ('yes', 'no'):
 
3451
            raise errors.UnexpectedSmartServerResponse(response)
 
3452
        return (response[0] == 'yes')
2323
3453
 
2324
3454
    def get_stacked_on_url(self):
2325
3455
        """Get the URL this branch is stacked against.
2352
3482
            self._is_stacked = False
2353
3483
        else:
2354
3484
            self._is_stacked = True
2355
 
        
 
3485
 
2356
3486
    def _vfs_get_tags_bytes(self):
2357
3487
        self._ensure_real()
2358
3488
        return self._real_branch._get_tags_bytes()
2359
3489
 
 
3490
    @needs_read_lock
2360
3491
    def _get_tags_bytes(self):
 
3492
        if self._tags_bytes is None:
 
3493
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3494
        return self._tags_bytes
 
3495
 
 
3496
    def _get_tags_bytes_via_hpss(self):
2361
3497
        medium = self._client._medium
2362
3498
        if medium._is_remote_before((1, 13)):
2363
3499
            return self._vfs_get_tags_bytes()
2373
3509
        return self._real_branch._set_tags_bytes(bytes)
2374
3510
 
2375
3511
    def _set_tags_bytes(self, bytes):
 
3512
        if self.is_locked():
 
3513
            self._tags_bytes = bytes
2376
3514
        medium = self._client._medium
2377
3515
        if medium._is_remote_before((1, 18)):
2378
3516
            self._vfs_set_tags_bytes(bytes)
2387
3525
            self._vfs_set_tags_bytes(bytes)
2388
3526
 
2389
3527
    def lock_read(self):
 
3528
        """Lock the branch for read operations.
 
3529
 
 
3530
        :return: A bzrlib.lock.LogicalLockResult.
 
3531
        """
2390
3532
        self.repository.lock_read()
2391
3533
        if not self._lock_mode:
2392
3534
            self._note_lock('r')
2396
3538
                self._real_branch.lock_read()
2397
3539
        else:
2398
3540
            self._lock_count += 1
 
3541
        return lock.LogicalLockResult(self.unlock)
2399
3542
 
2400
3543
    def _remote_lock_write(self, token):
2401
3544
        if token is None:
2402
3545
            branch_token = repo_token = ''
2403
3546
        else:
2404
3547
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
3548
            repo_token = self.repository.lock_write().repository_token
2406
3549
            self.repository.unlock()
2407
3550
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
3551
        try:
 
3552
            response = self._call(
 
3553
                'Branch.lock_write', self._remote_path(), branch_token,
 
3554
                repo_token or '', **err_context)
 
3555
        except errors.LockContention, e:
 
3556
            # The LockContention from the server doesn't have any
 
3557
            # information about the lock_url. We re-raise LockContention
 
3558
            # with valid lock_url.
 
3559
            raise errors.LockContention('(remote lock)',
 
3560
                self.repository.base.split('.bzr/')[0])
2411
3561
        if response[0] != 'ok':
2412
3562
            raise errors.UnexpectedSmartServerResponse(response)
2413
3563
        ok, branch_token, repo_token = response
2434
3584
            self._lock_mode = 'w'
2435
3585
            self._lock_count = 1
2436
3586
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3587
            raise errors.ReadOnlyError(self)
2438
3588
        else:
2439
3589
            if token is not None:
2440
3590
                # A token was given to lock_write, and we're relocking, so
2445
3595
            self._lock_count += 1
2446
3596
            # Re-lock the repository too.
2447
3597
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3598
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3599
 
2450
3600
    def _unlock(self, branch_token, repo_token):
2451
3601
        err_context = {'token': str((branch_token, repo_token))}
2489
3639
            self.repository.unlock()
2490
3640
 
2491
3641
    def break_lock(self):
2492
 
        self._ensure_real()
2493
 
        return self._real_branch.break_lock()
 
3642
        try:
 
3643
            response = self._call(
 
3644
                'Branch.break_lock', self._remote_path())
 
3645
        except errors.UnknownSmartMethod:
 
3646
            self._ensure_real()
 
3647
            return self._real_branch.break_lock()
 
3648
        if response != ('ok',):
 
3649
            raise errors.UnexpectedSmartServerResponse(response)
2494
3650
 
2495
3651
    def leave_lock_in_place(self):
2496
3652
        if not self._lock_token:
2520
3676
            missing_parent = parent_map[missing_parent]
2521
3677
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3678
 
2523
 
    def _last_revision_info(self):
 
3679
    def _read_last_revision_info(self):
2524
3680
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3681
        if response[0] != 'ok':
2526
3682
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3745
            raise errors.UnexpectedSmartServerResponse(response)
2590
3746
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3747
 
 
3748
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3749
    @needs_write_lock
2593
3750
    def set_revision_history(self, rev_history):
 
3751
        """See Branch.set_revision_history."""
 
3752
        self._set_revision_history(rev_history)
 
3753
 
 
3754
    @needs_write_lock
 
3755
    def _set_revision_history(self, rev_history):
2594
3756
        # Send just the tip revision of the history; the server will generate
2595
3757
        # the full history from that.  If the revision doesn't exist in this
2596
3758
        # branch, NoSuchRevision will be raised.
2654
3816
            _override_hook_target=self, **kwargs)
2655
3817
 
2656
3818
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3819
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3820
        self._ensure_real()
2659
3821
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3822
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3823
            _override_hook_source_branch=self)
2662
3824
 
2663
3825
    def is_locked(self):
2664
3826
        return self._lock_count >= 1
2665
3827
 
2666
3828
    @needs_read_lock
 
3829
    def revision_id_to_dotted_revno(self, revision_id):
 
3830
        """Given a revision id, return its dotted revno.
 
3831
 
 
3832
        :return: a tuple like (1,) or (400,1,3).
 
3833
        """
 
3834
        try:
 
3835
            response = self._call('Branch.revision_id_to_revno',
 
3836
                self._remote_path(), revision_id)
 
3837
        except errors.UnknownSmartMethod:
 
3838
            self._ensure_real()
 
3839
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3840
        if response[0] == 'ok':
 
3841
            return tuple([int(x) for x in response[1:]])
 
3842
        else:
 
3843
            raise errors.UnexpectedSmartServerResponse(response)
 
3844
 
 
3845
    @needs_read_lock
2667
3846
    def revision_id_to_revno(self, revision_id):
2668
 
        self._ensure_real()
2669
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3847
        """Given a revision id on the branch mainline, return its revno.
 
3848
 
 
3849
        :return: an integer
 
3850
        """
 
3851
        try:
 
3852
            response = self._call('Branch.revision_id_to_revno',
 
3853
                self._remote_path(), revision_id)
 
3854
        except errors.UnknownSmartMethod:
 
3855
            self._ensure_real()
 
3856
            return self._real_branch.revision_id_to_revno(revision_id)
 
3857
        if response[0] == 'ok':
 
3858
            if len(response) == 2:
 
3859
                return int(response[1])
 
3860
            raise NoSuchRevision(self, revision_id)
 
3861
        else:
 
3862
            raise errors.UnexpectedSmartServerResponse(response)
2670
3863
 
2671
3864
    @needs_write_lock
2672
3865
    def set_last_revision_info(self, revno, revision_id):
2673
3866
        # XXX: These should be returned by the set_last_revision_info verb
2674
3867
        old_revno, old_revid = self.last_revision_info()
2675
3868
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3869
        if not revision_id or not isinstance(revision_id, basestring):
 
3870
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3871
        try:
2678
3872
            response = self._call('Branch.set_last_revision_info',
2679
3873
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3902
            except errors.UnknownSmartMethod:
2709
3903
                medium._remember_remote_is_before((1, 6))
2710
3904
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3905
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3906
            last_rev=last_rev,other_branch=other_branch))
2713
3907
 
2714
3908
    def set_push_location(self, location):
2715
3909
        self._ensure_real()
2716
3910
        return self._real_branch.set_push_location(location)
2717
3911
 
 
3912
    def heads_to_fetch(self):
 
3913
        if self._format._use_default_local_heads_to_fetch():
 
3914
            # We recognise this format, and its heads-to-fetch implementation
 
3915
            # is the default one (tip + tags).  In this case it's cheaper to
 
3916
            # just use the default implementation rather than a special RPC as
 
3917
            # the tip and tags data is cached.
 
3918
            return branch.Branch.heads_to_fetch(self)
 
3919
        medium = self._client._medium
 
3920
        if medium._is_remote_before((2, 4)):
 
3921
            return self._vfs_heads_to_fetch()
 
3922
        try:
 
3923
            return self._rpc_heads_to_fetch()
 
3924
        except errors.UnknownSmartMethod:
 
3925
            medium._remember_remote_is_before((2, 4))
 
3926
            return self._vfs_heads_to_fetch()
 
3927
 
 
3928
    def _rpc_heads_to_fetch(self):
 
3929
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3930
        if len(response) != 2:
 
3931
            raise errors.UnexpectedSmartServerResponse(response)
 
3932
        must_fetch, if_present_fetch = response
 
3933
        return set(must_fetch), set(if_present_fetch)
 
3934
 
 
3935
    def _vfs_heads_to_fetch(self):
 
3936
        self._ensure_real()
 
3937
        return self._real_branch.heads_to_fetch()
 
3938
 
2718
3939
 
2719
3940
class RemoteConfig(object):
2720
3941
    """A Config that reads and writes from smart verbs.
2734
3955
        """
2735
3956
        try:
2736
3957
            configobj = self._get_configobj()
 
3958
            section_obj = None
2737
3959
            if section is None:
2738
3960
                section_obj = configobj
2739
3961
            else:
2740
3962
                try:
2741
3963
                    section_obj = configobj[section]
2742
3964
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3965
                    pass
 
3966
            if section_obj is None:
 
3967
                value = default
 
3968
            else:
 
3969
                value = section_obj.get(name, default)
2745
3970
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3971
            value = self._vfs_get_option(name, section, default)
 
3972
        for hook in _mod_config.OldConfigHooks['get']:
 
3973
            hook(self, name, value)
 
3974
        return value
2747
3975
 
2748
3976
    def _response_to_configobj(self, response):
2749
3977
        if len(response[0]) and response[0][0] != 'ok':
2750
3978
            raise errors.UnexpectedSmartServerResponse(response)
2751
3979
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3980
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
3981
        for hook in _mod_config.OldConfigHooks['load']:
 
3982
            hook(self)
 
3983
        return conf
2753
3984
 
2754
3985
 
2755
3986
class RemoteBranchConfig(RemoteConfig):
2774
4005
        medium = self._branch._client._medium
2775
4006
        if medium._is_remote_before((1, 14)):
2776
4007
            return self._vfs_set_option(value, name, section)
 
4008
        if isinstance(value, dict):
 
4009
            if medium._is_remote_before((2, 2)):
 
4010
                return self._vfs_set_option(value, name, section)
 
4011
            return self._set_config_option_dict(value, name, section)
 
4012
        else:
 
4013
            return self._set_config_option(value, name, section)
 
4014
 
 
4015
    def _set_config_option(self, value, name, section):
2777
4016
        try:
2778
4017
            path = self._branch._remote_path()
2779
4018
            response = self._branch._client.call('Branch.set_config_option',
2780
4019
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
4020
                value.encode('utf8'), name, section or '')
2782
4021
        except errors.UnknownSmartMethod:
 
4022
            medium = self._branch._client._medium
2783
4023
            medium._remember_remote_is_before((1, 14))
2784
4024
            return self._vfs_set_option(value, name, section)
2785
4025
        if response != ():
2786
4026
            raise errors.UnexpectedSmartServerResponse(response)
2787
4027
 
 
4028
    def _serialize_option_dict(self, option_dict):
 
4029
        utf8_dict = {}
 
4030
        for key, value in option_dict.items():
 
4031
            if isinstance(key, unicode):
 
4032
                key = key.encode('utf8')
 
4033
            if isinstance(value, unicode):
 
4034
                value = value.encode('utf8')
 
4035
            utf8_dict[key] = value
 
4036
        return bencode.bencode(utf8_dict)
 
4037
 
 
4038
    def _set_config_option_dict(self, value, name, section):
 
4039
        try:
 
4040
            path = self._branch._remote_path()
 
4041
            serialised_dict = self._serialize_option_dict(value)
 
4042
            response = self._branch._client.call(
 
4043
                'Branch.set_config_option_dict',
 
4044
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4045
                serialised_dict, name, section or '')
 
4046
        except errors.UnknownSmartMethod:
 
4047
            medium = self._branch._client._medium
 
4048
            medium._remember_remote_is_before((2, 2))
 
4049
            return self._vfs_set_option(value, name, section)
 
4050
        if response != ():
 
4051
            raise errors.UnexpectedSmartServerResponse(response)
 
4052
 
2788
4053
    def _real_object(self):
2789
4054
        self._branch._ensure_real()
2790
4055
        return self._branch._real_branch
2829
4094
        return self._bzrdir._real_bzrdir
2830
4095
 
2831
4096
 
2832
 
 
2833
4097
def _extract_tar(tar, to_dir):
2834
4098
    """Extract all the contents of a tarfile object.
2835
4099
 
2839
4103
        tar.extract(tarinfo, to_dir)
2840
4104
 
2841
4105
 
 
4106
error_translators = registry.Registry()
 
4107
no_context_error_translators = registry.Registry()
 
4108
 
 
4109
 
2842
4110
def _translate_error(err, **context):
2843
4111
    """Translate an ErrorFromSmartServer into a more useful error.
2844
4112
 
2873
4141
                    'Missing key %r in context %r', key_err.args[0], context)
2874
4142
                raise err
2875
4143
 
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'):
 
4144
    try:
 
4145
        translator = error_translators.get(err.error_verb)
 
4146
    except KeyError:
 
4147
        pass
 
4148
    else:
 
4149
        raise translator(err, find, get_path)
 
4150
    try:
 
4151
        translator = no_context_error_translators.get(err.error_verb)
 
4152
    except KeyError:
 
4153
        raise errors.UnknownErrorFromSmartServer(err)
 
4154
    else:
 
4155
        raise translator(err)
 
4156
 
 
4157
 
 
4158
error_translators.register('NoSuchRevision',
 
4159
    lambda err, find, get_path: NoSuchRevision(
 
4160
        find('branch'), err.error_args[0]))
 
4161
error_translators.register('nosuchrevision',
 
4162
    lambda err, find, get_path: NoSuchRevision(
 
4163
        find('repository'), err.error_args[0]))
 
4164
 
 
4165
def _translate_nobranch_error(err, find, get_path):
 
4166
    if len(err.error_args) >= 1:
 
4167
        extra = err.error_args[0]
 
4168
    else:
 
4169
        extra = None
 
4170
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4171
        detail=extra)
 
4172
 
 
4173
error_translators.register('nobranch', _translate_nobranch_error)
 
4174
error_translators.register('norepository',
 
4175
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4176
        find('bzrdir')))
 
4177
error_translators.register('UnlockableTransport',
 
4178
    lambda err, find, get_path: errors.UnlockableTransport(
 
4179
        find('bzrdir').root_transport))
 
4180
error_translators.register('TokenMismatch',
 
4181
    lambda err, find, get_path: errors.TokenMismatch(
 
4182
        find('token'), '(remote token)'))
 
4183
error_translators.register('Diverged',
 
4184
    lambda err, find, get_path: errors.DivergedBranches(
 
4185
        find('branch'), find('other_branch')))
 
4186
error_translators.register('NotStacked',
 
4187
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4188
 
 
4189
def _translate_PermissionDenied(err, find, get_path):
 
4190
    path = get_path()
 
4191
    if len(err.error_args) >= 2:
 
4192
        extra = err.error_args[1]
 
4193
    else:
 
4194
        extra = None
 
4195
    return errors.PermissionDenied(path, extra=extra)
 
4196
 
 
4197
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4198
error_translators.register('ReadError',
 
4199
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4200
error_translators.register('NoSuchFile',
 
4201
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4202
error_translators.register('TokenLockingNotSupported',
 
4203
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4204
        find('repository')))
 
4205
error_translators.register('UnsuspendableWriteGroup',
 
4206
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4207
        repository=find('repository')))
 
4208
error_translators.register('UnresumableWriteGroup',
 
4209
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4210
        repository=find('repository'), write_groups=err.error_args[0],
 
4211
        reason=err.error_args[1]))
 
4212
no_context_error_translators.register('IncompatibleRepositories',
 
4213
    lambda err: errors.IncompatibleRepositories(
 
4214
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4215
no_context_error_translators.register('LockContention',
 
4216
    lambda err: errors.LockContention('(remote lock)'))
 
4217
no_context_error_translators.register('LockFailed',
 
4218
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4219
no_context_error_translators.register('TipChangeRejected',
 
4220
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4221
no_context_error_translators.register('UnstackableBranchFormat',
 
4222
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4223
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4224
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4225
no_context_error_translators.register('FileExists',
 
4226
    lambda err: errors.FileExists(err.error_args[0]))
 
4227
no_context_error_translators.register('DirectoryNotEmpty',
 
4228
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4229
 
 
4230
def _translate_short_readv_error(err):
 
4231
    args = err.error_args
 
4232
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4233
        int(args[3]))
 
4234
 
 
4235
no_context_error_translators.register('ShortReadvError',
 
4236
    _translate_short_readv_error)
 
4237
 
 
4238
def _translate_unicode_error(err):
2932
4239
        encoding = str(err.error_args[0]) # encoding must always be a string
2933
4240
        val = err.error_args[1]
2934
4241
        start = int(err.error_args[2])
2942
4249
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2943
4250
        elif err.error_verb == 'UnicodeEncodeError':
2944
4251
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
 
    elif err.error_verb == 'ReadOnlyError':
2946
 
        raise errors.TransportNotPossible('readonly transport')
2947
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4252
 
 
4253
no_context_error_translators.register('UnicodeEncodeError',
 
4254
    _translate_unicode_error)
 
4255
no_context_error_translators.register('UnicodeDecodeError',
 
4256
    _translate_unicode_error)
 
4257
no_context_error_translators.register('ReadOnlyError',
 
4258
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4259
no_context_error_translators.register('MemoryError',
 
4260
    lambda err: errors.BzrError("remote server out of memory\n"
 
4261
        "Retry non-remotely, or contact the server admin for details."))
 
4262
no_context_error_translators.register('RevisionNotPresent',
 
4263
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4264
 
 
4265
no_context_error_translators.register('BzrCheckError',
 
4266
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4267