/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: Martin Pool
  • Date: 2011-11-29 00:50:36 UTC
  • mto: This revision was merged to the branch mainline in revision 6320.
  • Revision ID: mbp@canonical.com-20111129005036-1vopao4wm0yo9ekn
Slight cleanup of TimeoutFixture

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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import bz2
 
18
import zlib
18
19
 
19
20
from bzrlib import (
20
21
    bencode,
21
22
    branch,
22
 
    bzrdir,
 
23
    bzrdir as _mod_bzrdir,
23
24
    config,
 
25
    controldir,
24
26
    debug,
25
27
    errors,
 
28
    gpg,
26
29
    graph,
27
30
    lock,
28
31
    lockdir,
29
 
    repository,
 
32
    osutils,
 
33
    registry,
30
34
    repository as _mod_repository,
31
 
    revision,
32
35
    revision as _mod_revision,
33
36
    static_tuple,
34
37
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
38
    testament as _mod_testament,
 
39
    urlutils,
 
40
    vf_repository,
 
41
    )
 
42
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
43
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
44
from bzrlib.errors import (
40
45
    NoSuchRevision,
41
46
    SmartProtocolError,
42
47
    )
 
48
from bzrlib.i18n import gettext
 
49
from bzrlib.inventory import Inventory
43
50
from bzrlib.lockable_files import LockableFiles
44
51
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
 
52
from bzrlib.smart.client import _SmartClient
 
53
from bzrlib.revision import NULL_REVISION
 
54
from bzrlib.revisiontree import InventoryRevisionTree
 
55
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
56
from bzrlib.serializer import format_registry as serializer_format_registry
 
57
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
58
 
 
59
 
 
60
_DEFAULT_SEARCH_DEPTH = 100
47
61
 
48
62
 
49
63
class _RpcHelper(object):
86
100
    return format
87
101
 
88
102
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
103
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
104
# does not have to be imported unless a remote format is involved.
 
105
 
 
106
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
107
    """Format representing bzrdirs accessed via a smart server"""
 
108
 
 
109
    supports_workingtrees = False
 
110
 
 
111
    def __init__(self):
 
112
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
113
        # XXX: It's a bit ugly that the network name is here, because we'd
 
114
        # like to believe that format objects are stateless or at least
 
115
        # immutable,  However, we do at least avoid mutating the name after
 
116
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
117
        self._network_name = None
 
118
 
 
119
    def __repr__(self):
 
120
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
121
            self._network_name)
 
122
 
 
123
    def get_format_description(self):
 
124
        if self._network_name:
 
125
            try:
 
126
                real_format = controldir.network_format_registry.get(
 
127
                        self._network_name)
 
128
            except KeyError:
 
129
                pass
 
130
            else:
 
131
                return 'Remote: ' + real_format.get_format_description()
 
132
        return 'bzr remote bzrdir'
 
133
 
 
134
    def get_format_string(self):
 
135
        raise NotImplementedError(self.get_format_string)
 
136
 
 
137
    def network_name(self):
 
138
        if self._network_name:
 
139
            return self._network_name
 
140
        else:
 
141
            raise AssertionError("No network name set.")
 
142
 
 
143
    def initialize_on_transport(self, transport):
 
144
        try:
 
145
            # hand off the request to the smart server
 
146
            client_medium = transport.get_smart_medium()
 
147
        except errors.NoSmartMedium:
 
148
            # TODO: lookup the local format from a server hint.
 
149
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
150
            return local_dir_format.initialize_on_transport(transport)
 
151
        client = _SmartClient(client_medium)
 
152
        path = client.remote_path_from_transport(transport)
 
153
        try:
 
154
            response = client.call('BzrDirFormat.initialize', path)
 
155
        except errors.ErrorFromSmartServer, err:
 
156
            _translate_error(err, path=path)
 
157
        if response[0] != 'ok':
 
158
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
159
        format = RemoteBzrDirFormat()
 
160
        self._supply_sub_formats_to(format)
 
161
        return RemoteBzrDir(transport, format)
 
162
 
 
163
    def parse_NoneTrueFalse(self, arg):
 
164
        if not arg:
 
165
            return None
 
166
        if arg == 'False':
 
167
            return False
 
168
        if arg == 'True':
 
169
            return True
 
170
        raise AssertionError("invalid arg %r" % arg)
 
171
 
 
172
    def _serialize_NoneTrueFalse(self, arg):
 
173
        if arg is False:
 
174
            return 'False'
 
175
        if arg:
 
176
            return 'True'
 
177
        return ''
 
178
 
 
179
    def _serialize_NoneString(self, arg):
 
180
        return arg or ''
 
181
 
 
182
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
183
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
184
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
185
        shared_repo=False):
 
186
        try:
 
187
            # hand off the request to the smart server
 
188
            client_medium = transport.get_smart_medium()
 
189
        except errors.NoSmartMedium:
 
190
            do_vfs = True
 
191
        else:
 
192
            # Decline to open it if the server doesn't support our required
 
193
            # version (3) so that the VFS-based transport will do it.
 
194
            if client_medium.should_probe():
 
195
                try:
 
196
                    server_version = client_medium.protocol_version()
 
197
                    if server_version != '2':
 
198
                        do_vfs = True
 
199
                    else:
 
200
                        do_vfs = False
 
201
                except errors.SmartProtocolError:
 
202
                    # Apparently there's no usable smart server there, even though
 
203
                    # the medium supports the smart protocol.
 
204
                    do_vfs = True
 
205
            else:
 
206
                do_vfs = False
 
207
        if not do_vfs:
 
208
            client = _SmartClient(client_medium)
 
209
            path = client.remote_path_from_transport(transport)
 
210
            if client_medium._is_remote_before((1, 16)):
 
211
                do_vfs = True
 
212
        if do_vfs:
 
213
            # TODO: lookup the local format from a server hint.
 
214
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
215
            self._supply_sub_formats_to(local_dir_format)
 
216
            return local_dir_format.initialize_on_transport_ex(transport,
 
217
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
218
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
219
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
220
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
221
                vfs_only=True)
 
222
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
223
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
224
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
225
 
 
226
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
227
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
228
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
229
        args = []
 
230
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
231
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
232
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
233
        args.append(self._serialize_NoneString(stacked_on))
 
234
        # stack_on_pwd is often/usually our transport
 
235
        if stack_on_pwd:
 
236
            try:
 
237
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
238
                if not stack_on_pwd:
 
239
                    stack_on_pwd = '.'
 
240
            except errors.PathNotChild:
 
241
                pass
 
242
        args.append(self._serialize_NoneString(stack_on_pwd))
 
243
        args.append(self._serialize_NoneString(repo_format_name))
 
244
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
245
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
246
        request_network_name = self._network_name or \
 
247
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
248
        try:
 
249
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
250
                request_network_name, path, *args)
 
251
        except errors.UnknownSmartMethod:
 
252
            client._medium._remember_remote_is_before((1,16))
 
253
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
254
            self._supply_sub_formats_to(local_dir_format)
 
255
            return local_dir_format.initialize_on_transport_ex(transport,
 
256
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
257
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
258
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
259
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
260
                vfs_only=True)
 
261
        except errors.ErrorFromSmartServer, err:
 
262
            _translate_error(err, path=path)
 
263
        repo_path = response[0]
 
264
        bzrdir_name = response[6]
 
265
        require_stacking = response[7]
 
266
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
267
        format = RemoteBzrDirFormat()
 
268
        format._network_name = bzrdir_name
 
269
        self._supply_sub_formats_to(format)
 
270
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
271
        if repo_path:
 
272
            repo_format = response_tuple_to_repo_format(response[1:])
 
273
            if repo_path == '.':
 
274
                repo_path = ''
 
275
            if repo_path:
 
276
                repo_bzrdir_format = RemoteBzrDirFormat()
 
277
                repo_bzrdir_format._network_name = response[5]
 
278
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
279
                    repo_bzrdir_format)
 
280
            else:
 
281
                repo_bzr = bzrdir
 
282
            final_stack = response[8] or None
 
283
            final_stack_pwd = response[9] or None
 
284
            if final_stack_pwd:
 
285
                final_stack_pwd = urlutils.join(
 
286
                    transport.base, final_stack_pwd)
 
287
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
288
            if len(response) > 10:
 
289
                # Updated server verb that locks remotely.
 
290
                repo_lock_token = response[10] or None
 
291
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
292
                if repo_lock_token:
 
293
                    remote_repo.dont_leave_lock_in_place()
 
294
            else:
 
295
                remote_repo.lock_write()
 
296
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
297
                final_stack_pwd, require_stacking)
 
298
            policy.acquire_repository()
 
299
        else:
 
300
            remote_repo = None
 
301
            policy = None
 
302
        bzrdir._format.set_branch_format(self.get_branch_format())
 
303
        if require_stacking:
 
304
            # The repo has already been created, but we need to make sure that
 
305
            # we'll make a stackable branch.
 
306
            bzrdir._format.require_stacking(_skip_repo=True)
 
307
        return remote_repo, bzrdir, require_stacking, policy
 
308
 
 
309
    def _open(self, transport):
 
310
        return RemoteBzrDir(transport, self)
 
311
 
 
312
    def __eq__(self, other):
 
313
        if not isinstance(other, RemoteBzrDirFormat):
 
314
            return False
 
315
        return self.get_format_description() == other.get_format_description()
 
316
 
 
317
    def __return_repository_format(self):
 
318
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
319
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
320
        # that it should use that for init() etc.
 
321
        result = RemoteRepositoryFormat()
 
322
        custom_format = getattr(self, '_repository_format', None)
 
323
        if custom_format:
 
324
            if isinstance(custom_format, RemoteRepositoryFormat):
 
325
                return custom_format
 
326
            else:
 
327
                # We will use the custom format to create repositories over the
 
328
                # wire; expose its details like rich_root_data for code to
 
329
                # query
 
330
                result._custom_format = custom_format
 
331
        return result
 
332
 
 
333
    def get_branch_format(self):
 
334
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
335
        if not isinstance(result, RemoteBranchFormat):
 
336
            new_result = RemoteBranchFormat()
 
337
            new_result._custom_format = result
 
338
            # cache the result
 
339
            self.set_branch_format(new_result)
 
340
            result = new_result
 
341
        return result
 
342
 
 
343
    repository_format = property(__return_repository_format,
 
344
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
345
 
 
346
 
 
347
class RemoteControlStore(config.IniFileStore):
 
348
    """Control store which attempts to use HPSS calls to retrieve control store.
 
349
 
 
350
    Note that this is specific to bzr-based formats.
 
351
    """
 
352
 
 
353
    def __init__(self, bzrdir):
 
354
        super(RemoteControlStore, self).__init__()
 
355
        self.bzrdir = bzrdir
 
356
        self._real_store = None
 
357
 
 
358
    def lock_write(self, token=None):
 
359
        self._ensure_real()
 
360
        return self._real_store.lock_write(token)
 
361
 
 
362
    def unlock(self):
 
363
        self._ensure_real()
 
364
        return self._real_store.unlock()
 
365
 
 
366
    @needs_write_lock
 
367
    def save(self):
 
368
        # We need to be able to override the undecorated implementation
 
369
        self.save_without_locking()
 
370
 
 
371
    def save_without_locking(self):
 
372
        super(RemoteControlStore, self).save()
 
373
 
 
374
    def _ensure_real(self):
 
375
        self.bzrdir._ensure_real()
 
376
        if self._real_store is None:
 
377
            self._real_store = config.ControlStore(self.bzrdir)
 
378
 
 
379
    def external_url(self):
 
380
        return self.bzrdir.user_url
 
381
 
 
382
    def _load_content(self):
 
383
        medium = self.bzrdir._client._medium
 
384
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
385
        try:
 
386
            response, handler = self.bzrdir._call_expecting_body(
 
387
                'BzrDir.get_config_file', path)
 
388
        except errors.UnknownSmartMethod:
 
389
            self._ensure_real()
 
390
            return self._real_store._load_content()
 
391
        if len(response) and response[0] != 'ok':
 
392
            raise errors.UnexpectedSmartServerResponse(response)
 
393
        return handler.read_body_bytes()
 
394
 
 
395
    def _save_content(self, content):
 
396
        # FIXME JRV 2011-11-22: Ideally this should use a
 
397
        # HPSS call too, but at the moment it is not possible
 
398
        # to write lock control directories.
 
399
        self._ensure_real()
 
400
        return self._real_store._save_content(content)
 
401
 
 
402
 
 
403
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
404
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
405
 
94
406
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
409
        :param _client: Private parameter for testing. Disables probing and the
98
410
            use of a real bzrdir.
99
411
        """
100
 
        BzrDir.__init__(self, transport, format)
 
412
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
413
        # this object holds a delegated bzrdir that uses file-level operations
102
414
        # to talk to the other side
103
415
        self._real_bzrdir = None
163
475
                import traceback
164
476
                warning('VFS BzrDir access triggered\n%s',
165
477
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
478
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
479
                self.root_transport, _server_formats=False)
168
480
            self._format._network_name = \
169
481
                self._real_bzrdir._format.network_name()
175
487
        # Prevent aliasing problems in the next_open_branch_result cache.
176
488
        # See create_branch for rationale.
177
489
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
490
        return _mod_bzrdir.BzrDir.break_lock(self)
179
491
 
180
492
    def _vfs_cloning_metadir(self, require_stacking=False):
181
493
        self._ensure_real()
212
524
        if len(branch_info) != 2:
213
525
            raise errors.UnexpectedSmartServerResponse(response)
214
526
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
527
        try:
 
528
            format = controldir.network_format_registry.get(control_name)
 
529
        except KeyError:
 
530
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
531
 
216
532
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
218
 
                repo_name)
 
533
            try:
 
534
                format.repository_format = _mod_repository.network_format_registry.get(
 
535
                    repo_name)
 
536
            except KeyError:
 
537
                raise errors.UnknownFormatError(kind='repository',
 
538
                    format=repo_name)
219
539
        if branch_ref == 'ref':
220
540
            # XXX: we need possible_transports here to avoid reopening the
221
541
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
542
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
543
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
544
            format.set_branch_format(branch_format)
225
545
        elif branch_ref == 'branch':
226
546
            if branch_name:
227
 
                format.set_branch_format(
228
 
                    branch.network_format_registry.get(branch_name))
 
547
                try:
 
548
                    branch_format = branch.network_format_registry.get(
 
549
                        branch_name)
 
550
                except KeyError:
 
551
                    raise errors.UnknownFormatError(kind='branch',
 
552
                        format=branch_name)
 
553
                format.set_branch_format(branch_format)
229
554
        else:
230
555
            raise errors.UnexpectedSmartServerResponse(response)
231
556
        return format
241
566
 
242
567
    def destroy_repository(self):
243
568
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
569
        path = self._path_for_remote_call(self._client)
 
570
        try:
 
571
            response = self._call('BzrDir.destroy_repository', path)
 
572
        except errors.UnknownSmartMethod:
 
573
            self._ensure_real()
 
574
            self._real_bzrdir.destroy_repository()
 
575
            return
 
576
        if response[0] != 'ok':
 
577
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
578
 
247
 
    def create_branch(self, name=None):
 
579
    def create_branch(self, name=None, repository=None,
 
580
                      append_revisions_only=None):
248
581
        # as per meta1 formats - just delegate to the format object which may
249
582
        # be parameterised.
250
583
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
584
            name=name, repository=repository,
 
585
            append_revisions_only=append_revisions_only)
252
586
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
587
            if not isinstance(repository, RemoteRepository):
 
588
                raise AssertionError(
 
589
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
590
                    % (repository,))
 
591
            result = RemoteBranch(self, repository, real_branch, name=name)
255
592
        else:
256
593
            result = real_branch
257
594
        # BzrDir.clone_on_transport() uses the result of create_branch but does
265
602
 
266
603
    def destroy_branch(self, name=None):
267
604
        """See BzrDir.destroy_branch"""
268
 
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
605
        path = self._path_for_remote_call(self._client)
 
606
        try:
 
607
            if name is not None:
 
608
                args = (name, )
 
609
            else:
 
610
                args = ()
 
611
            response = self._call('BzrDir.destroy_branch', path, *args)
 
612
        except errors.UnknownSmartMethod:
 
613
            self._ensure_real()
 
614
            self._real_bzrdir.destroy_branch(name=name)
 
615
            self._next_open_branch_result = None
 
616
            return
270
617
        self._next_open_branch_result = None
 
618
        if response[0] != 'ok':
 
619
            raise SmartProtocolError('unexpected response code %s' % (response,))
271
620
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
621
    def create_workingtree(self, revision_id=None, from_branch=None,
 
622
        accelerator_tree=None, hardlink=False):
273
623
        raise errors.NotLocalUrl(self.transport.base)
274
624
 
275
 
    def find_branch_format(self):
 
625
    def find_branch_format(self, name=None):
276
626
        """Find the branch 'format' for this bzrdir.
277
627
 
278
628
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
629
        """
280
 
        b = self.open_branch()
 
630
        b = self.open_branch(name=name)
281
631
        return b._format
282
632
 
283
 
    def get_branch_reference(self):
 
633
    def get_branch_reference(self, name=None):
284
634
        """See BzrDir.get_branch_reference()."""
 
635
        if name is not None:
 
636
            # XXX JRV20100304: Support opening colocated branches
 
637
            raise errors.NoColocatedBranchSupport(self)
285
638
        response = self._get_branch_reference()
286
639
        if response[0] == 'ref':
287
640
            return response[1]
318
671
            raise errors.UnexpectedSmartServerResponse(response)
319
672
        return response
320
673
 
321
 
    def _get_tree_branch(self):
 
674
    def _get_tree_branch(self, name=None):
322
675
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
676
        return None, self.open_branch(name=name)
324
677
 
325
678
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
 
679
                    ignore_fallbacks=False, possible_transports=None):
327
680
        if unsupported:
328
681
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
682
        if self._next_open_branch_result is not None:
336
689
            # a branch reference, use the existing BranchReference logic.
337
690
            format = BranchReferenceFormat()
338
691
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
692
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
693
                possible_transports=possible_transports)
340
694
        branch_format_name = response[1]
341
695
        if not branch_format_name:
342
696
            branch_format_name = None
343
697
        format = RemoteBranchFormat(network_name=branch_format_name)
344
698
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
 
699
            setup_stacking=not ignore_fallbacks, name=name,
 
700
            possible_transports=possible_transports)
346
701
 
347
702
    def _open_repo_v1(self, path):
348
703
        verb = 'BzrDir.find_repository'
411
766
 
412
767
    def has_workingtree(self):
413
768
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
769
            path = self._path_for_remote_call(self._client)
 
770
            try:
 
771
                response = self._call('BzrDir.has_workingtree', path)
 
772
            except errors.UnknownSmartMethod:
 
773
                self._ensure_real()
 
774
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
775
            else:
 
776
                if response[0] not in ('yes', 'no'):
 
777
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
778
                self._has_working_tree = (response[0] == 'yes')
416
779
        return self._has_working_tree
417
780
 
418
781
    def open_workingtree(self, recommend_upgrade=True):
423
786
 
424
787
    def _path_for_remote_call(self, client):
425
788
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
789
        return urlutils.split_segment_parameters_raw(
 
790
            client.remote_path_from_transport(self.root_transport))[0]
427
791
 
428
792
    def get_branch_transport(self, branch_format, name=None):
429
793
        self._ensure_real()
441
805
        """Upgrading of remote bzrdirs is not supported yet."""
442
806
        return False
443
807
 
444
 
    def needs_format_conversion(self, format=None):
 
808
    def needs_format_conversion(self, format):
445
809
        """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
810
        return False
450
811
 
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
812
    def _get_config(self):
458
813
        return RemoteBzrDirConfig(self)
459
814
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
815
    def _get_config_store(self):
 
816
        return RemoteControlStore(self)
 
817
 
 
818
 
 
819
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
820
    """Format for repositories accessed over a _SmartClient.
463
821
 
464
822
    Instances of this repository are represented by RemoteRepository
479
837
    """
480
838
 
481
839
    _matchingbzrdir = RemoteBzrDirFormat()
 
840
    supports_full_versioned_files = True
 
841
    supports_leaving_lock = True
482
842
 
483
843
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
844
        _mod_repository.RepositoryFormat.__init__(self)
485
845
        self._custom_format = None
486
846
        self._network_name = None
487
847
        self._creating_bzrdir = None
 
848
        self._revision_graph_can_have_wrong_parents = None
488
849
        self._supports_chks = None
489
850
        self._supports_external_lookups = None
490
851
        self._supports_tree_reference = None
 
852
        self._supports_funky_characters = None
 
853
        self._supports_nesting_repositories = None
491
854
        self._rich_root_data = None
492
855
 
493
856
    def __repr__(self):
522
885
        return self._supports_external_lookups
523
886
 
524
887
    @property
 
888
    def supports_funky_characters(self):
 
889
        if self._supports_funky_characters is None:
 
890
            self._ensure_real()
 
891
            self._supports_funky_characters = \
 
892
                self._custom_format.supports_funky_characters
 
893
        return self._supports_funky_characters
 
894
 
 
895
    @property
 
896
    def supports_nesting_repositories(self):
 
897
        if self._supports_nesting_repositories is None:
 
898
            self._ensure_real()
 
899
            self._supports_nesting_repositories = \
 
900
                self._custom_format.supports_nesting_repositories
 
901
        return self._supports_nesting_repositories
 
902
 
 
903
    @property
525
904
    def supports_tree_reference(self):
526
905
        if self._supports_tree_reference is None:
527
906
            self._ensure_real()
529
908
                self._custom_format.supports_tree_reference
530
909
        return self._supports_tree_reference
531
910
 
 
911
    @property
 
912
    def revision_graph_can_have_wrong_parents(self):
 
913
        if self._revision_graph_can_have_wrong_parents is None:
 
914
            self._ensure_real()
 
915
            self._revision_graph_can_have_wrong_parents = \
 
916
                self._custom_format.revision_graph_can_have_wrong_parents
 
917
        return self._revision_graph_can_have_wrong_parents
 
918
 
532
919
    def _vfs_initialize(self, a_bzrdir, shared):
533
920
        """Helper for common code in initialize."""
534
921
        if self._custom_format:
569
956
            network_name = self._network_name
570
957
        else:
571
958
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
959
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
960
            reference_format = reference_bzrdir_format.repository_format
574
961
            network_name = reference_format.network_name()
575
962
        # 2) try direct creation via RPC
601
988
 
602
989
    def _ensure_real(self):
603
990
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
605
 
                self._network_name)
 
991
            try:
 
992
                self._custom_format = _mod_repository.network_format_registry.get(
 
993
                    self._network_name)
 
994
            except KeyError:
 
995
                raise errors.UnknownFormatError(kind='repository',
 
996
                    format=self._network_name)
606
997
 
607
998
    @property
608
999
    def _fetch_order(self):
643
1034
        return self._custom_format._serializer
644
1035
 
645
1036
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1037
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1038
        lock._RelockDebugMixin):
648
1039
    """Repository accessed over rpc.
649
1040
 
650
1041
    For the moment most operations are performed using local transport-backed
674
1065
        self._format = format
675
1066
        self._lock_mode = None
676
1067
        self._lock_token = None
 
1068
        self._write_group_tokens = None
677
1069
        self._lock_count = 0
678
1070
        self._leave_lock = False
679
1071
        # Cache of revision parents; misses are cached during read locks, and
703
1095
        # transport, but I'm not sure it's worth making this method
704
1096
        # optional -- mbp 2010-04-21
705
1097
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1098
 
707
1099
    def __str__(self):
708
1100
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1101
 
719
1111
 
720
1112
        :param suppress_errors: see Repository.abort_write_group.
721
1113
        """
722
 
        self._ensure_real()
723
 
        return self._real_repository.abort_write_group(
724
 
            suppress_errors=suppress_errors)
 
1114
        if self._real_repository:
 
1115
            self._ensure_real()
 
1116
            return self._real_repository.abort_write_group(
 
1117
                suppress_errors=suppress_errors)
 
1118
        if not self.is_in_write_group():
 
1119
            if suppress_errors:
 
1120
                mutter('(suppressed) not in write group')
 
1121
                return
 
1122
            raise errors.BzrError("not in write group")
 
1123
        path = self.bzrdir._path_for_remote_call(self._client)
 
1124
        try:
 
1125
            response = self._call('Repository.abort_write_group', path,
 
1126
                self._lock_token, self._write_group_tokens)
 
1127
        except Exception, exc:
 
1128
            self._write_group = None
 
1129
            if not suppress_errors:
 
1130
                raise
 
1131
            mutter('abort_write_group failed')
 
1132
            log_exception_quietly()
 
1133
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1134
        else:
 
1135
            if response != ('ok', ):
 
1136
                raise errors.UnexpectedSmartServerResponse(response)
 
1137
            self._write_group_tokens = None
725
1138
 
726
1139
    @property
727
1140
    def chk_bytes(self):
741
1154
        for older plugins that don't use e.g. the CommitBuilder
742
1155
        facility.
743
1156
        """
744
 
        self._ensure_real()
745
 
        return self._real_repository.commit_write_group()
 
1157
        if self._real_repository:
 
1158
            self._ensure_real()
 
1159
            return self._real_repository.commit_write_group()
 
1160
        if not self.is_in_write_group():
 
1161
            raise errors.BzrError("not in write group")
 
1162
        path = self.bzrdir._path_for_remote_call(self._client)
 
1163
        response = self._call('Repository.commit_write_group', path,
 
1164
            self._lock_token, self._write_group_tokens)
 
1165
        if response != ('ok', ):
 
1166
            raise errors.UnexpectedSmartServerResponse(response)
 
1167
        self._write_group_tokens = None
746
1168
 
747
1169
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
 
1170
        if self._real_repository:
 
1171
            return self._real_repository.resume_write_group(tokens)
 
1172
        path = self.bzrdir._path_for_remote_call(self._client)
 
1173
        try:
 
1174
            response = self._call('Repository.check_write_group', path,
 
1175
               self._lock_token, tokens)
 
1176
        except errors.UnknownSmartMethod:
 
1177
            self._ensure_real()
 
1178
            return self._real_repository.resume_write_group(tokens)
 
1179
        if response != ('ok', ):
 
1180
            raise errors.UnexpectedSmartServerResponse(response)
 
1181
        self._write_group_tokens = tokens
750
1182
 
751
1183
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
 
1184
        if self._real_repository:
 
1185
            return self._real_repository.suspend_write_group()
 
1186
        ret = self._write_group_tokens or []
 
1187
        self._write_group_tokens = None
 
1188
        return ret
754
1189
 
755
1190
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
1191
        self._ensure_real()
817
1252
    def find_text_key_references(self):
818
1253
        """Find the text key references within the repository.
819
1254
 
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
1255
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1256
            to whether they were referred to by the inventory of the
825
1257
            revision_id that they contain. The inventory texts from all present
843
1275
        """Private method for using with old (< 1.2) servers to fallback."""
844
1276
        if revision_id is None:
845
1277
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1278
        elif _mod_revision.is_null(revision_id):
847
1279
            return {}
848
1280
 
849
1281
        path = self.bzrdir._path_for_remote_call(self._client)
873
1305
        return RemoteStreamSource(self, to_format)
874
1306
 
875
1307
    @needs_read_lock
 
1308
    def get_file_graph(self):
 
1309
        return graph.Graph(self.texts)
 
1310
 
 
1311
    @needs_read_lock
876
1312
    def has_revision(self, revision_id):
877
1313
        """True if this repository has a copy of the revision."""
878
1314
        # Copy of bzrlib.repository.Repository.has_revision
895
1331
    def _has_same_fallbacks(self, other_repo):
896
1332
        """Returns true if the repositories have the same fallbacks."""
897
1333
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1334
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1335
        my_fb = self._fallback_repositories
900
1336
        other_fb = other_repo._fallback_repositories
901
1337
        if len(my_fb) != len(other_fb):
930
1366
        """See Repository.gather_stats()."""
931
1367
        path = self.bzrdir._path_for_remote_call(self._client)
932
1368
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1369
        if revid is None or _mod_revision.is_null(revid):
934
1370
            fmt_revid = ''
935
1371
        else:
936
1372
            fmt_revid = revid
965
1401
 
966
1402
    def get_physical_lock_status(self):
967
1403
        """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()
 
1404
        path = self.bzrdir._path_for_remote_call(self._client)
 
1405
        try:
 
1406
            response = self._call('Repository.get_physical_lock_status', path)
 
1407
        except errors.UnknownSmartMethod:
 
1408
            self._ensure_real()
 
1409
            return self._real_repository.get_physical_lock_status()
 
1410
        if response[0] not in ('yes', 'no'):
 
1411
            raise errors.UnexpectedSmartServerResponse(response)
 
1412
        return (response[0] == 'yes')
971
1413
 
972
1414
    def is_in_write_group(self):
973
1415
        """Return True if there is an open write group.
974
1416
 
975
1417
        write groups are only applicable locally for the smart server..
976
1418
        """
 
1419
        if self._write_group_tokens is not None:
 
1420
            return True
977
1421
        if self._real_repository:
978
1422
            return self._real_repository.is_in_write_group()
979
1423
 
997
1441
        pass
998
1442
 
999
1443
    def lock_read(self):
 
1444
        """Lock the repository for read operations.
 
1445
 
 
1446
        :return: A bzrlib.lock.LogicalLockResult.
 
1447
        """
1000
1448
        # wrong eventually - want a local lock cache context
1001
1449
        if not self._lock_mode:
1002
1450
            self._note_lock('r')
1009
1457
                repo.lock_read()
1010
1458
        else:
1011
1459
            self._lock_count += 1
 
1460
        return lock.LogicalLockResult(self.unlock)
1012
1461
 
1013
1462
    def _remote_lock_write(self, token):
1014
1463
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1503
            raise errors.ReadOnlyError(self)
1055
1504
        else:
1056
1505
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1506
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1507
 
1059
1508
    def leave_lock_in_place(self):
1060
1509
        if not self._lock_token:
1109
1558
            self._real_repository.lock_write(self._lock_token)
1110
1559
        elif self._lock_mode == 'r':
1111
1560
            self._real_repository.lock_read()
 
1561
        if self._write_group_tokens is not None:
 
1562
            # if we are already in a write group, resume it
 
1563
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1564
            self._write_group_tokens = None
1112
1565
 
1113
1566
    def start_write_group(self):
1114
1567
        """Start a write group on the decorated repository.
1118
1571
        for older plugins that don't use e.g. the CommitBuilder
1119
1572
        facility.
1120
1573
        """
1121
 
        self._ensure_real()
1122
 
        return self._real_repository.start_write_group()
 
1574
        if self._real_repository:
 
1575
            self._ensure_real()
 
1576
            return self._real_repository.start_write_group()
 
1577
        if not self.is_write_locked():
 
1578
            raise errors.NotWriteLocked(self)
 
1579
        if self._write_group_tokens is not None:
 
1580
            raise errors.BzrError('already in a write group')
 
1581
        path = self.bzrdir._path_for_remote_call(self._client)
 
1582
        try:
 
1583
            response = self._call('Repository.start_write_group', path,
 
1584
                self._lock_token)
 
1585
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1586
            self._ensure_real()
 
1587
            return self._real_repository.start_write_group()
 
1588
        if response[0] != 'ok':
 
1589
            raise errors.UnexpectedSmartServerResponse(response)
 
1590
        self._write_group_tokens = response[1]
1123
1591
 
1124
1592
    def _unlock(self, token):
1125
1593
        path = self.bzrdir._path_for_remote_call(self._client)
1152
1620
            # This is just to let the _real_repository stay up to date.
1153
1621
            if self._real_repository is not None:
1154
1622
                self._real_repository.unlock()
 
1623
            elif self._write_group_tokens is not None:
 
1624
                self.abort_write_group()
1155
1625
        finally:
1156
1626
            # The rpc-level lock should be released even if there was a
1157
1627
            # problem releasing the vfs-based lock.
1169
1639
 
1170
1640
    def break_lock(self):
1171
1641
        # should hand off to the network
1172
 
        self._ensure_real()
1173
 
        return self._real_repository.break_lock()
 
1642
        path = self.bzrdir._path_for_remote_call(self._client)
 
1643
        try:
 
1644
            response = self._call("Repository.break_lock", path)
 
1645
        except errors.UnknownSmartMethod:
 
1646
            self._ensure_real()
 
1647
            return self._real_repository.break_lock()
 
1648
        if response != ('ok',):
 
1649
            raise errors.UnexpectedSmartServerResponse(response)
1174
1650
 
1175
1651
    def _get_tarball(self, compression):
1176
1652
        """Return a TemporaryFile containing a repository tarball.
1194
1670
            return t
1195
1671
        raise errors.UnexpectedSmartServerResponse(response)
1196
1672
 
 
1673
    @needs_read_lock
1197
1674
    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)
 
1675
        """Create a descendent repository for new development.
 
1676
 
 
1677
        Unlike clone, this does not copy the settings of the repository.
 
1678
        """
 
1679
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1680
        dest_repo.fetch(self, revision_id=revision_id)
1203
1681
        return dest_repo
1204
1682
 
 
1683
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1684
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1685
            # use target default format.
 
1686
            dest_repo = a_bzrdir.create_repository()
 
1687
        else:
 
1688
            # Most control formats need the repository to be specifically
 
1689
            # created, but on some old all-in-one formats it's not needed
 
1690
            try:
 
1691
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1692
            except errors.UninitializableFormat:
 
1693
                dest_repo = a_bzrdir.open_repository()
 
1694
        return dest_repo
 
1695
 
1205
1696
    ### These methods are just thin shims to the VFS object for now.
1206
1697
 
 
1698
    @needs_read_lock
1207
1699
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1700
        revision_id = _mod_revision.ensure_null(revision_id)
 
1701
        if revision_id == _mod_revision.NULL_REVISION:
 
1702
            return InventoryRevisionTree(self,
 
1703
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1704
        else:
 
1705
            return list(self.revision_trees([revision_id]))[0]
1210
1706
 
1211
1707
    def get_serializer_format(self):
1212
 
        self._ensure_real()
1213
 
        return self._real_repository.get_serializer_format()
 
1708
        path = self.bzrdir._path_for_remote_call(self._client)
 
1709
        try:
 
1710
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1711
                path)
 
1712
        except errors.UnknownSmartMethod:
 
1713
            self._ensure_real()
 
1714
            return self._real_repository.get_serializer_format()
 
1715
        if response[0] != 'ok':
 
1716
            raise errors.UnexpectedSmartServerResponse(response)
 
1717
        return response[1]
1214
1718
 
1215
1719
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1720
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1721
                           revision_id=None, lossy=False):
1218
1722
        # FIXME: It ought to be possible to call this without immediately
1219
1723
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1724
        self._ensure_real()
1221
1725
        real_repo = self._real_repository
1222
1726
        builder = real_repo.get_commit_builder(branch, parents,
1223
1727
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1728
                committer=committer, revprops=revprops,
 
1729
                revision_id=revision_id, lossy=lossy)
1225
1730
        return builder
1226
1731
 
1227
1732
    def add_fallback_repository(self, repository):
1235
1740
        # We need to accumulate additional repositories here, to pass them in
1236
1741
        # on various RPC's.
1237
1742
        #
 
1743
        # Make the check before we lock: this raises an exception.
 
1744
        self._check_fallback_repository(repository)
1238
1745
        if self.is_locked():
1239
1746
            # We will call fallback.unlock() when we transition to the unlocked
1240
1747
            # state, so always add a lock here. If a caller passes us a locked
1241
1748
            # repository, they are responsible for unlocking it later.
1242
1749
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1750
        self._fallback_repositories.append(repository)
1245
1751
        # If self._real_repository was parameterised already (e.g. because a
1246
1752
        # _real_branch had its get_stacked_on_url method called), then the
1279
1785
 
1280
1786
    @needs_read_lock
1281
1787
    def get_inventory(self, revision_id):
1282
 
        self._ensure_real()
1283
 
        return self._real_repository.get_inventory(revision_id)
 
1788
        return list(self.iter_inventories([revision_id]))[0]
1284
1789
 
1285
1790
    def iter_inventories(self, revision_ids, ordering=None):
1286
1791
        self._ensure_real()
1288
1793
 
1289
1794
    @needs_read_lock
1290
1795
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1796
        return self.get_revisions([revision_id])[0]
1293
1797
 
1294
1798
    def get_transaction(self):
1295
1799
        self._ensure_real()
1297
1801
 
1298
1802
    @needs_read_lock
1299
1803
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1804
        dest_repo = self._create_sprouting_repo(
 
1805
            a_bzrdir, shared=self.is_shared())
 
1806
        self.copy_content_into(dest_repo, revision_id)
 
1807
        return dest_repo
1302
1808
 
1303
1809
    def make_working_trees(self):
1304
1810
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1811
        path = self.bzrdir._path_for_remote_call(self._client)
 
1812
        try:
 
1813
            response = self._call('Repository.make_working_trees', path)
 
1814
        except errors.UnknownSmartMethod:
 
1815
            self._ensure_real()
 
1816
            return self._real_repository.make_working_trees()
 
1817
        if response[0] not in ('yes', 'no'):
 
1818
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1819
        return response[0] == 'yes'
1307
1820
 
1308
1821
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1822
        """Re-read any data needed to synchronise with disk.
1310
1823
 
1311
1824
        This method is intended to be called after another repository instance
1312
1825
        (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.
 
1826
        repository. On all repositories this will work outside of write groups.
 
1827
        Some repository formats (pack and newer for bzrlib native formats)
 
1828
        support refresh_data inside write groups. If called inside a write
 
1829
        group on a repository that does not support refreshing in a write group
 
1830
        IsInWriteGroupError will be raised.
1315
1831
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1832
        if self._real_repository is not None:
1320
1833
            self._real_repository.refresh_data()
1321
1834
 
1333
1846
        return result
1334
1847
 
1335
1848
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1849
    def search_missing_revision_ids(self, other,
 
1850
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1851
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1852
            limit=None):
1337
1853
        """Return the revision ids that other has that this does not.
1338
1854
 
1339
1855
        These are returned in topological order.
1340
1856
 
1341
1857
        revision_id: only return revision ids included by revision_id.
1342
1858
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1859
        if symbol_versioning.deprecated_passed(revision_id):
 
1860
            symbol_versioning.warn(
 
1861
                'search_missing_revision_ids(revision_id=...) was '
 
1862
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1863
                DeprecationWarning, stacklevel=2)
 
1864
            if revision_ids is not None:
 
1865
                raise AssertionError(
 
1866
                    'revision_ids is mutually exclusive with revision_id')
 
1867
            if revision_id is not None:
 
1868
                revision_ids = [revision_id]
 
1869
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1870
        return inter_repo.search_missing_revision_ids(
 
1871
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1872
            if_present_ids=if_present_ids, limit=limit)
1345
1873
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1874
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1875
            fetch_spec=None):
1348
1876
        # No base implementation to use as RemoteRepository is not a subclass
1349
1877
        # of Repository; so this is a copy of Repository.fetch().
1360
1888
            # check that last_revision is in 'from' and then return a
1361
1889
            # no-operation.
1362
1890
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1891
                not _mod_revision.is_null(revision_id)):
1364
1892
                self.get_revision(revision_id)
1365
1893
            return 0, []
1366
1894
        # if there is no specific appropriate InterRepository, this will get
1367
1895
        # the InterRepository base class, which raises an
1368
1896
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1897
        inter = _mod_repository.InterRepository.get(source, self)
 
1898
        return inter.fetch(revision_id=revision_id,
1371
1899
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1900
 
1373
1901
    def create_bundle(self, target, base, fileobj, format=None):
1375
1903
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1904
 
1377
1905
    @needs_read_lock
 
1906
    @symbol_versioning.deprecated_method(
 
1907
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1908
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1909
        self._ensure_real()
1380
1910
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1388
1918
        return self._real_repository._get_versioned_file_checker(
1389
1919
            revisions, revision_versions_cache)
1390
1920
 
 
1921
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
1922
        path = self.bzrdir._path_for_remote_call(self._client)
 
1923
        lines = []
 
1924
        identifiers = []
 
1925
        for (file_id, revid, identifier) in desired_files:
 
1926
            lines.append("%s\0%s" % (
 
1927
                osutils.safe_file_id(file_id),
 
1928
                osutils.safe_revision_id(revid)))
 
1929
            identifiers.append(identifier)
 
1930
        (response_tuple, response_handler) = (
 
1931
            self._call_with_body_bytes_expecting_body(
 
1932
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
1933
        if response_tuple != ('ok', ):
 
1934
            response_handler.cancel_read_body()
 
1935
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1936
        byte_stream = response_handler.read_streamed_body()
 
1937
        def decompress_stream(start, byte_stream, unused):
 
1938
            decompressor = zlib.decompressobj()
 
1939
            yield decompressor.decompress(start)
 
1940
            while decompressor.unused_data == "":
 
1941
                try:
 
1942
                    data = byte_stream.next()
 
1943
                except StopIteration:
 
1944
                    break
 
1945
                yield decompressor.decompress(data)
 
1946
            yield decompressor.flush()
 
1947
            unused.append(decompressor.unused_data)
 
1948
        unused = ""
 
1949
        while True:
 
1950
            while not "\n" in unused:
 
1951
                unused += byte_stream.next()
 
1952
            header, rest = unused.split("\n", 1)
 
1953
            args = header.split("\0")
 
1954
            if args[0] == "absent":
 
1955
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
1956
                unused = rest
 
1957
                continue
 
1958
            elif args[0] == "ok":
 
1959
                idx = int(args[1])
 
1960
            else:
 
1961
                raise errors.UnexpectedSmartServerResponse(args)
 
1962
            unused_chunks = []
 
1963
            yield (identifiers[idx],
 
1964
                decompress_stream(rest, byte_stream, unused_chunks))
 
1965
            unused = "".join(unused_chunks)
 
1966
 
1391
1967
    def iter_files_bytes(self, desired_files):
1392
1968
        """See Repository.iter_file_bytes.
1393
1969
        """
1394
 
        self._ensure_real()
1395
 
        return self._real_repository.iter_files_bytes(desired_files)
 
1970
        try:
 
1971
            absent = {}
 
1972
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
1973
                    desired_files, absent):
 
1974
                yield identifier, bytes_iterator
 
1975
            for fallback in self._fallback_repositories:
 
1976
                if not absent:
 
1977
                    break
 
1978
                desired_files = [(key[0], key[1], identifier) for
 
1979
                    (identifier, key) in absent.iteritems()]
 
1980
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
1981
                    del absent[identifier]
 
1982
                    yield identifier, bytes_iterator
 
1983
            if absent:
 
1984
                # There may be more missing items, but raise an exception
 
1985
                # for just one.
 
1986
                missing_identifier = absent.keys()[0]
 
1987
                missing_key = absent[missing_identifier]
 
1988
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
1989
                    file_id=missing_key[0])
 
1990
        except errors.UnknownSmartMethod:
 
1991
            self._ensure_real()
 
1992
            for (identifier, bytes_iterator) in (
 
1993
                self._real_repository.iter_files_bytes(desired_files)):
 
1994
                yield identifier, bytes_iterator
 
1995
 
 
1996
    def get_cached_parent_map(self, revision_ids):
 
1997
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1998
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1396
1999
 
1397
2000
    def get_parent_map(self, revision_ids):
1398
2001
        """See bzrlib.Graph.get_parent_map()."""
1457
2060
        if parents_map is None:
1458
2061
            # Repository is not locked, so there's no cache.
1459
2062
            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)
 
2063
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2064
            (start_set, stop_keys,
 
2065
             key_count) = graph.search_result_from_parent_map(
 
2066
                parents_map, self._unstacked_provider.missing_keys)
 
2067
        else:
 
2068
            (start_set, stop_keys,
 
2069
             key_count) = graph.limited_search_result_from_parent_map(
 
2070
                parents_map, self._unstacked_provider.missing_keys,
 
2071
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
2072
        recipe = ('manual', start_set, stop_keys, key_count)
1481
2073
        body = self._serialise_search_recipe(recipe)
1482
2074
        path = self.bzrdir._path_for_remote_call(self._client)
1531
2123
 
1532
2124
    @needs_read_lock
1533
2125
    def get_signature_text(self, revision_id):
1534
 
        self._ensure_real()
1535
 
        return self._real_repository.get_signature_text(revision_id)
 
2126
        path = self.bzrdir._path_for_remote_call(self._client)
 
2127
        try:
 
2128
            response_tuple, response_handler = self._call_expecting_body(
 
2129
                'Repository.get_revision_signature_text', path, revision_id)
 
2130
        except errors.UnknownSmartMethod:
 
2131
            self._ensure_real()
 
2132
            return self._real_repository.get_signature_text(revision_id)
 
2133
        except errors.NoSuchRevision, err:
 
2134
            for fallback in self._fallback_repositories:
 
2135
                try:
 
2136
                    return fallback.get_signature_text(revision_id)
 
2137
                except errors.NoSuchRevision:
 
2138
                    pass
 
2139
            raise err
 
2140
        else:
 
2141
            if response_tuple[0] != 'ok':
 
2142
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2143
            return response_handler.read_body_bytes()
1536
2144
 
1537
2145
    @needs_read_lock
1538
2146
    def _get_inventory_xml(self, revision_id):
1544
2152
        return self._real_repository.reconcile(other=other, thorough=thorough)
1545
2153
 
1546
2154
    def all_revision_ids(self):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.all_revision_ids()
 
2155
        path = self.bzrdir._path_for_remote_call(self._client)
 
2156
        try:
 
2157
            response_tuple, response_handler = self._call_expecting_body(
 
2158
                "Repository.all_revision_ids", path)
 
2159
        except errors.UnknownSmartMethod:
 
2160
            self._ensure_real()
 
2161
            return self._real_repository.all_revision_ids()
 
2162
        if response_tuple != ("ok", ):
 
2163
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2164
        revids = set(response_handler.read_body_bytes().splitlines())
 
2165
        for fallback in self._fallback_repositories:
 
2166
            revids.update(set(fallback.all_revision_ids()))
 
2167
        return list(revids)
1549
2168
 
1550
2169
    @needs_read_lock
1551
2170
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1555
2174
 
1556
2175
    @needs_read_lock
1557
2176
    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)
 
2177
        r = self.get_revision(revision_id)
 
2178
        return list(self.get_deltas_for_revisions([r],
 
2179
            specific_fileids=specific_fileids))[0]
1561
2180
 
1562
2181
    @needs_read_lock
1563
2182
    def revision_trees(self, revision_ids):
1564
 
        self._ensure_real()
1565
 
        return self._real_repository.revision_trees(revision_ids)
 
2183
        inventories = self.iter_inventories(revision_ids)
 
2184
        for inv in inventories:
 
2185
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1566
2186
 
1567
2187
    @needs_read_lock
1568
2188
    def get_revision_reconcile(self, revision_id):
1576
2196
            callback_refs=callback_refs, check_repo=check_repo)
1577
2197
 
1578
2198
    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)
 
2199
        """Make a complete copy of the content in self into destination.
 
2200
 
 
2201
        This is a destructive operation! Do not use it on existing
 
2202
        repositories.
 
2203
        """
 
2204
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2205
        return interrepo.copy_content(revision_id)
1582
2206
 
1583
2207
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2208
        # get a tarball of the remote repository, and copy from that into the
1585
2209
        # destination
1586
 
        from bzrlib import osutils
1587
2210
        import tarfile
1588
2211
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2212
        note(gettext("Copying repository content as tarball..."))
1590
2213
        tar_file = self._get_tarball('bz2')
1591
2214
        if tar_file is None:
1592
2215
            return None
1597
2220
            tmpdir = osutils.mkdtemp()
1598
2221
            try:
1599
2222
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2223
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2224
                tmp_repo = tmp_bzrdir.open_repository()
1602
2225
                tmp_repo.copy_content_into(destination, revision_id)
1603
2226
            finally:
1621
2244
    @needs_write_lock
1622
2245
    def pack(self, hint=None, clean_obsolete_packs=False):
1623
2246
        """Compress the data within the repository.
1624
 
 
1625
 
        This is not currently implemented within the smart server.
1626
2247
        """
1627
 
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2248
        if hint is None:
 
2249
            body = ""
 
2250
        else:
 
2251
            body = "".join([l+"\n" for l in hint])
 
2252
        path = self.bzrdir._path_for_remote_call(self._client)
 
2253
        try:
 
2254
            response, handler = self._call_with_body_bytes_expecting_body(
 
2255
                'Repository.pack', (path, self._lock_token,
 
2256
                    str(clean_obsolete_packs)), body)
 
2257
        except errors.UnknownSmartMethod:
 
2258
            self._ensure_real()
 
2259
            return self._real_repository.pack(hint=hint,
 
2260
                clean_obsolete_packs=clean_obsolete_packs)
 
2261
        handler.cancel_read_body()
 
2262
        if response != ('ok', ):
 
2263
            raise errors.UnexpectedSmartServerResponse(response)
1629
2264
 
1630
2265
    @property
1631
2266
    def revisions(self):
1632
2267
        """Decorate the real repository for now.
1633
2268
 
1634
 
        In the short term this should become a real object to intercept graph
1635
 
        lookups.
1636
 
 
1637
2269
        In the long term a full blown network facility is needed.
1638
2270
        """
1639
2271
        self._ensure_real()
1667
2299
 
1668
2300
    @needs_write_lock
1669
2301
    def sign_revision(self, revision_id, gpg_strategy):
1670
 
        self._ensure_real()
1671
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2302
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2303
        plaintext = testament.as_short_text()
 
2304
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1672
2305
 
1673
2306
    @property
1674
2307
    def texts(self):
1680
2313
        self._ensure_real()
1681
2314
        return self._real_repository.texts
1682
2315
 
 
2316
    def _iter_revisions_rpc(self, revision_ids):
 
2317
        body = "\n".join(revision_ids)
 
2318
        path = self.bzrdir._path_for_remote_call(self._client)
 
2319
        response_tuple, response_handler = (
 
2320
            self._call_with_body_bytes_expecting_body(
 
2321
            "Repository.iter_revisions", (path, ), body))
 
2322
        if response_tuple[0] != "ok":
 
2323
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2324
        serializer_format = response_tuple[1]
 
2325
        serializer = serializer_format_registry.get(serializer_format)
 
2326
        byte_stream = response_handler.read_streamed_body()
 
2327
        decompressor = zlib.decompressobj()
 
2328
        chunks = []
 
2329
        for bytes in byte_stream:
 
2330
            chunks.append(decompressor.decompress(bytes))
 
2331
            if decompressor.unused_data != "":
 
2332
                chunks.append(decompressor.flush())
 
2333
                yield serializer.read_revision_from_string("".join(chunks))
 
2334
                unused = decompressor.unused_data
 
2335
                decompressor = zlib.decompressobj()
 
2336
                chunks = [decompressor.decompress(unused)]
 
2337
        chunks.append(decompressor.flush())
 
2338
        text = "".join(chunks)
 
2339
        if text != "":
 
2340
            yield serializer.read_revision_from_string("".join(chunks))
 
2341
 
1683
2342
    @needs_read_lock
1684
2343
    def get_revisions(self, revision_ids):
1685
 
        self._ensure_real()
1686
 
        return self._real_repository.get_revisions(revision_ids)
 
2344
        if revision_ids is None:
 
2345
            revision_ids = self.all_revision_ids()
 
2346
        else:
 
2347
            for rev_id in revision_ids:
 
2348
                if not rev_id or not isinstance(rev_id, basestring):
 
2349
                    raise errors.InvalidRevisionId(
 
2350
                        revision_id=rev_id, branch=self)
 
2351
        try:
 
2352
            missing = set(revision_ids)
 
2353
            revs = {}
 
2354
            for rev in self._iter_revisions_rpc(revision_ids):
 
2355
                missing.remove(rev.revision_id)
 
2356
                revs[rev.revision_id] = rev
 
2357
        except errors.UnknownSmartMethod:
 
2358
            self._ensure_real()
 
2359
            return self._real_repository.get_revisions(revision_ids)
 
2360
        for fallback in self._fallback_repositories:
 
2361
            if not missing:
 
2362
                break
 
2363
            for revid in list(missing):
 
2364
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2365
                # public method on Repository that could be used to query
 
2366
                # for revision objects *without* failing completely if one
 
2367
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2368
                # but unfortunately that's private and not provided by
 
2369
                # all repository implementations.
 
2370
                try:
 
2371
                    revs[revid] = fallback.get_revision(revid)
 
2372
                except errors.NoSuchRevision:
 
2373
                    pass
 
2374
                else:
 
2375
                    missing.remove(revid)
 
2376
        if missing:
 
2377
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2378
        return [revs[revid] for revid in revision_ids]
1687
2379
 
1688
2380
    def supports_rich_root(self):
1689
2381
        return self._format.rich_root_data
1690
2382
 
 
2383
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2384
    def iter_reverse_revision_history(self, revision_id):
1692
2385
        self._ensure_real()
1693
2386
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2389
    def _serializer(self):
1697
2390
        return self._format._serializer
1698
2391
 
 
2392
    @needs_write_lock
1699
2393
    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)
 
2394
        signature = gpg_strategy.sign(plaintext)
 
2395
        self.add_signature_text(revision_id, signature)
1703
2396
 
1704
2397
    def add_signature_text(self, revision_id, signature):
1705
 
        self._ensure_real()
1706
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2398
        if self._real_repository:
 
2399
            # If there is a real repository the write group will
 
2400
            # be in the real repository as well, so use that:
 
2401
            self._ensure_real()
 
2402
            return self._real_repository.add_signature_text(
 
2403
                revision_id, signature)
 
2404
        path = self.bzrdir._path_for_remote_call(self._client)
 
2405
        response, handler = self._call_with_body_bytes_expecting_body(
 
2406
            'Repository.add_signature_text', (path, self._lock_token,
 
2407
                revision_id) + tuple(self._write_group_tokens), signature)
 
2408
        handler.cancel_read_body()
 
2409
        self.refresh_data()
 
2410
        if response[0] != 'ok':
 
2411
            raise errors.UnexpectedSmartServerResponse(response)
 
2412
        self._write_group_tokens = response[1:]
1707
2413
 
1708
2414
    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)
 
2415
        path = self.bzrdir._path_for_remote_call(self._client)
 
2416
        try:
 
2417
            response = self._call('Repository.has_signature_for_revision_id',
 
2418
                path, revision_id)
 
2419
        except errors.UnknownSmartMethod:
 
2420
            self._ensure_real()
 
2421
            return self._real_repository.has_signature_for_revision_id(
 
2422
                revision_id)
 
2423
        if response[0] not in ('yes', 'no'):
 
2424
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2425
        if response[0] == 'yes':
 
2426
            return True
 
2427
        for fallback in self._fallback_repositories:
 
2428
            if fallback.has_signature_for_revision_id(revision_id):
 
2429
                return True
 
2430
        return False
 
2431
 
 
2432
    @needs_read_lock
 
2433
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2434
        if not self.has_signature_for_revision_id(revision_id):
 
2435
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2436
        signature = self.get_signature_text(revision_id)
 
2437
 
 
2438
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2439
        plaintext = testament.as_short_text()
 
2440
 
 
2441
        return gpg_strategy.verify(signature, plaintext)
1711
2442
 
1712
2443
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2444
        self._ensure_real()
1714
2445
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2446
            _files_pb=_files_pb)
1716
2447
 
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
2448
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2449
        self._ensure_real()
1724
2450
        return self._real_repository._find_inconsistent_revision_parents(
1732
2458
        providers = [self._unstacked_provider]
1733
2459
        if other is not None:
1734
2460
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2461
        return graph.StackedParentsProvider(_LazyListJoin(
 
2462
            providers, self._fallback_repositories))
1738
2463
 
1739
2464
    def _serialise_search_recipe(self, recipe):
1740
2465
        """Serialise a graph search recipe.
1748
2473
        return '\n'.join((start_keys, stop_keys, count))
1749
2474
 
1750
2475
    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)]
 
2476
        parts = search_result.get_network_struct()
1757
2477
        return '\n'.join(parts)
1758
2478
 
1759
2479
    def autopack(self):
1769
2489
            raise errors.UnexpectedSmartServerResponse(response)
1770
2490
 
1771
2491
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2492
class RemoteStreamSink(vf_repository.StreamSink):
1773
2493
 
1774
2494
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2495
        self.target_repo._ensure_real()
1876
2596
        self._last_substream and self._last_stream so that the stream can be
1877
2597
        resumed by _resume_stream_with_vfs.
1878
2598
        """
1879
 
                    
 
2599
 
1880
2600
        stream_iter = iter(stream)
1881
2601
        for substream_kind, substream in stream_iter:
1882
2602
            if substream_kind == 'inventory-deltas':
1885
2605
                return
1886
2606
            else:
1887
2607
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2608
 
 
2609
 
 
2610
class RemoteStreamSource(vf_repository.StreamSource):
1891
2611
    """Stream data from a remote server."""
1892
2612
 
1893
2613
    def get_stream(self, search):
1914
2634
 
1915
2635
    def _real_stream(self, repo, search):
1916
2636
        """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 
 
2637
 
 
2638
        This never called RemoteStreamSource.get_stream, and is a helper
 
2639
        for RemoteStreamSource._get_stream to allow getting a stream
1920
2640
        reliably whether fallback back because of old servers or trying
1921
2641
        to stream from a non-RemoteRepository (which the stacked support
1922
2642
        code will do).
1953
2673
        candidate_verbs = [
1954
2674
            ('Repository.get_stream_1.19', (1, 19)),
1955
2675
            ('Repository.get_stream', (1, 13))]
 
2676
 
1956
2677
        found_verb = False
1957
2678
        for verb, version in candidate_verbs:
1958
2679
            if medium._is_remote_before(version):
1962
2683
                    verb, args, search_bytes)
1963
2684
            except errors.UnknownSmartMethod:
1964
2685
                medium._remember_remote_is_before(version)
 
2686
            except errors.UnknownErrorFromSmartServer, e:
 
2687
                if isinstance(search, graph.EverythingResult):
 
2688
                    error_verb = e.error_from_smart_server.error_verb
 
2689
                    if error_verb == 'BadSearch':
 
2690
                        # Pre-2.4 servers don't support this sort of search.
 
2691
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2692
                        # good idea in general?  It might provide a little bit
 
2693
                        # of protection against client-side bugs.
 
2694
                        medium._remember_remote_is_before((2, 4))
 
2695
                        break
 
2696
                raise
1965
2697
            else:
1966
2698
                response_tuple, response_handler = response
1967
2699
                found_verb = True
1971
2703
        if response_tuple[0] != 'ok':
1972
2704
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2705
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2706
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2707
            self._record_counter)
1975
2708
        if src_format.network_name() != repo._format.network_name():
1976
2709
            raise AssertionError(
1977
2710
                "Mismatched RemoteRepository and stream src %r, %r" % (
2049
2782
 
2050
2783
    def _ensure_real(self):
2051
2784
        if self._custom_format is None:
2052
 
            self._custom_format = branch.network_format_registry.get(
2053
 
                self._network_name)
 
2785
            try:
 
2786
                self._custom_format = branch.network_format_registry.get(
 
2787
                    self._network_name)
 
2788
            except KeyError:
 
2789
                raise errors.UnknownFormatError(kind='branch',
 
2790
                    format=self._network_name)
2054
2791
 
2055
2792
    def get_format_description(self):
2056
2793
        self._ensure_real()
2063
2800
        return a_bzrdir.open_branch(name=name, 
2064
2801
            ignore_fallbacks=ignore_fallbacks)
2065
2802
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2803
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2804
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2805
        # method is not available on the server.
2069
2806
        # self._custom_format is always set - the start of initialize ensures
2071
2808
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2809
            a_bzrdir._ensure_real()
2073
2810
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2811
                name, append_revisions_only=append_revisions_only)
2075
2812
        else:
2076
2813
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2814
            result = self._custom_format.initialize(a_bzrdir, name,
 
2815
                append_revisions_only=append_revisions_only)
2078
2816
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2817
            not isinstance(result, RemoteBranch)):
2080
2818
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2819
                                  name=name)
2082
2820
        return result
2083
2821
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2822
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2823
                   append_revisions_only=None):
2085
2824
        # 1) get the network name to use.
2086
2825
        if self._custom_format:
2087
2826
            network_name = self._custom_format.network_name()
2088
2827
        else:
2089
2828
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2829
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2830
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2831
            self._custom_format = reference_format
2093
2832
            network_name = reference_format.network_name()
2094
2833
        # Being asked to create on a non RemoteBzrDir:
2095
2834
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2835
            return self._vfs_initialize(a_bzrdir, name=name,
 
2836
                append_revisions_only=append_revisions_only)
2097
2837
        medium = a_bzrdir._client._medium
2098
2838
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2839
            return self._vfs_initialize(a_bzrdir, name=name,
 
2840
                append_revisions_only=append_revisions_only)
2100
2841
        # Creating on a remote bzr dir.
2101
2842
        # 2) try direct creation via RPC
2102
2843
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2850
        except errors.UnknownSmartMethod:
2110
2851
            # Fallback - use vfs methods
2111
2852
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2853
            return self._vfs_initialize(a_bzrdir, name=name,
 
2854
                    append_revisions_only=append_revisions_only)
2113
2855
        if response[0] != 'ok':
2114
2856
            raise errors.UnexpectedSmartServerResponse(response)
2115
2857
        # Turn the response into a RemoteRepository object.
2116
2858
        format = RemoteBranchFormat(network_name=response[1])
2117
2859
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2860
        repo_path = response[2]
 
2861
        if repository is not None:
 
2862
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2863
            url_diff = urlutils.relative_url(repository.user_url,
 
2864
                    remote_repo_url)
 
2865
            if url_diff != '.':
 
2866
                raise AssertionError(
 
2867
                    'repository.user_url %r does not match URL from server '
 
2868
                    'response (%r + %r)'
 
2869
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2870
            remote_repo = repository
2120
2871
        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)
 
2872
            if repo_path == '':
 
2873
                repo_bzrdir = a_bzrdir
 
2874
            else:
 
2875
                repo_bzrdir = RemoteBzrDir(
 
2876
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2877
                    a_bzrdir._client)
 
2878
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2879
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2880
            format=format, setup_stacking=False, name=name)
 
2881
        if append_revisions_only:
 
2882
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2883
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2884
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2885
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2904
        self._ensure_real()
2149
2905
        return self._custom_format.supports_set_append_revisions_only()
2150
2906
 
 
2907
    def _use_default_local_heads_to_fetch(self):
 
2908
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2909
        # implementation is not overridden vs the base class, we can use the
 
2910
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2911
        # usually cheaper in terms of net round trips, as the last-revision and
 
2912
        # tags info fetched is cached and would be fetched anyway.
 
2913
        self._ensure_real()
 
2914
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2915
            branch_class = self._custom_format._branch_class()
 
2916
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2917
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2918
                return True
 
2919
        return False
 
2920
 
 
2921
 
 
2922
class RemoteBranchStore(config.IniFileStore):
 
2923
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2924
 
 
2925
    Note that this is specific to bzr-based formats.
 
2926
    """
 
2927
 
 
2928
    def __init__(self, branch):
 
2929
        super(RemoteBranchStore, self).__init__()
 
2930
        self.branch = branch
 
2931
        self.id = "branch"
 
2932
        self._real_store = None
 
2933
 
 
2934
    def lock_write(self, token=None):
 
2935
        return self.branch.lock_write(token)
 
2936
 
 
2937
    def unlock(self):
 
2938
        return self.branch.unlock()
 
2939
 
 
2940
    @needs_write_lock
 
2941
    def save(self):
 
2942
        # We need to be able to override the undecorated implementation
 
2943
        self.save_without_locking()
 
2944
 
 
2945
    def save_without_locking(self):
 
2946
        super(RemoteBranchStore, self).save()
 
2947
 
 
2948
    def external_url(self):
 
2949
        return self.branch.user_url
 
2950
 
 
2951
    def _load_content(self):
 
2952
        path = self.branch._remote_path()
 
2953
        try:
 
2954
            response, handler = self.branch._call_expecting_body(
 
2955
                'Branch.get_config_file', path)
 
2956
        except errors.UnknownSmartMethod:
 
2957
            self._ensure_real()
 
2958
            return self._real_store._load_content()
 
2959
        if len(response) and response[0] != 'ok':
 
2960
            raise errors.UnexpectedSmartServerResponse(response)
 
2961
        return handler.read_body_bytes()
 
2962
 
 
2963
    def _save_content(self, content):
 
2964
        path = self.branch._remote_path()
 
2965
        try:
 
2966
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
2967
                'Branch.put_config_file', (path,
 
2968
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2969
                content)
 
2970
        except errors.UnknownSmartMethod:
 
2971
            self._ensure_real()
 
2972
            return self._real_store._save_content(content)
 
2973
        handler.cancel_read_body()
 
2974
        if response != ('ok', ):
 
2975
            raise errors.UnexpectedSmartServerResponse(response)
 
2976
 
 
2977
    def _ensure_real(self):
 
2978
        self.branch._ensure_real()
 
2979
        if self._real_store is None:
 
2980
            self._real_store = config.BranchStore(self.branch)
 
2981
 
2151
2982
 
2152
2983
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2984
    """Branch stored on a server accessed by HPSS RPC.
2156
2987
    """
2157
2988
 
2158
2989
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
2990
        _client=None, format=None, setup_stacking=True, name=None,
 
2991
        possible_transports=None):
2160
2992
        """Create a RemoteBranch instance.
2161
2993
 
2162
2994
        :param real_branch: An optional local implementation of the branch
2227
3059
            hook(self)
2228
3060
        self._is_stacked = False
2229
3061
        if setup_stacking:
2230
 
            self._setup_stacking()
 
3062
            self._setup_stacking(possible_transports)
2231
3063
 
2232
 
    def _setup_stacking(self):
 
3064
    def _setup_stacking(self, possible_transports):
2233
3065
        # configure stacking into the remote repository, by reading it from
2234
3066
        # the vfs branch.
2235
3067
        try:
2238
3070
            errors.UnstackableRepositoryFormat), e:
2239
3071
            return
2240
3072
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
 
3073
        if possible_transports is None:
 
3074
            possible_transports = []
 
3075
        else:
 
3076
            possible_transports = list(possible_transports)
 
3077
        possible_transports.append(self.bzrdir.root_transport)
 
3078
        self._activate_fallback_location(fallback_url,
 
3079
            possible_transports=possible_transports)
2242
3080
 
2243
3081
    def _get_config(self):
2244
3082
        return RemoteBranchConfig(self)
2245
3083
 
 
3084
    def _get_config_store(self):
 
3085
        return RemoteBranchStore(self)
 
3086
 
2246
3087
    def _get_real_transport(self):
2247
3088
        # if we try vfs access, return the real branch's vfs transport
2248
3089
        self._ensure_real()
2311
3152
                self.bzrdir, self._client)
2312
3153
        return self._control_files
2313
3154
 
2314
 
    def _get_checkout_format(self):
 
3155
    def _get_checkout_format(self, lightweight=False):
2315
3156
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
3157
        if lightweight:
 
3158
            format = RemoteBzrDirFormat()
 
3159
            self.bzrdir._format._supply_sub_formats_to(format)
 
3160
            format.workingtree_format = self._real_branch._get_checkout_format(
 
3161
                lightweight=lightweight).workingtree_format
 
3162
            return format
 
3163
        else:
 
3164
            return self._real_branch._get_checkout_format(lightweight=False)
2317
3165
 
2318
3166
    def get_physical_lock_status(self):
2319
3167
        """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()
 
3168
        try:
 
3169
            response = self._client.call('Branch.get_physical_lock_status',
 
3170
                self._remote_path())
 
3171
        except errors.UnknownSmartMethod:
 
3172
            self._ensure_real()
 
3173
            return self._real_branch.get_physical_lock_status()
 
3174
        if response[0] not in ('yes', 'no'):
 
3175
            raise errors.UnexpectedSmartServerResponse(response)
 
3176
        return (response[0] == 'yes')
2323
3177
 
2324
3178
    def get_stacked_on_url(self):
2325
3179
        """Get the URL this branch is stacked against.
2352
3206
            self._is_stacked = False
2353
3207
        else:
2354
3208
            self._is_stacked = True
2355
 
        
 
3209
 
2356
3210
    def _vfs_get_tags_bytes(self):
2357
3211
        self._ensure_real()
2358
3212
        return self._real_branch._get_tags_bytes()
2359
3213
 
 
3214
    @needs_read_lock
2360
3215
    def _get_tags_bytes(self):
 
3216
        if self._tags_bytes is None:
 
3217
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3218
        return self._tags_bytes
 
3219
 
 
3220
    def _get_tags_bytes_via_hpss(self):
2361
3221
        medium = self._client._medium
2362
3222
        if medium._is_remote_before((1, 13)):
2363
3223
            return self._vfs_get_tags_bytes()
2373
3233
        return self._real_branch._set_tags_bytes(bytes)
2374
3234
 
2375
3235
    def _set_tags_bytes(self, bytes):
 
3236
        if self.is_locked():
 
3237
            self._tags_bytes = bytes
2376
3238
        medium = self._client._medium
2377
3239
        if medium._is_remote_before((1, 18)):
2378
3240
            self._vfs_set_tags_bytes(bytes)
2387
3249
            self._vfs_set_tags_bytes(bytes)
2388
3250
 
2389
3251
    def lock_read(self):
 
3252
        """Lock the branch for read operations.
 
3253
 
 
3254
        :return: A bzrlib.lock.LogicalLockResult.
 
3255
        """
2390
3256
        self.repository.lock_read()
2391
3257
        if not self._lock_mode:
2392
3258
            self._note_lock('r')
2396
3262
                self._real_branch.lock_read()
2397
3263
        else:
2398
3264
            self._lock_count += 1
 
3265
        return lock.LogicalLockResult(self.unlock)
2399
3266
 
2400
3267
    def _remote_lock_write(self, token):
2401
3268
        if token is None:
2402
3269
            branch_token = repo_token = ''
2403
3270
        else:
2404
3271
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
3272
            repo_token = self.repository.lock_write().repository_token
2406
3273
            self.repository.unlock()
2407
3274
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
3275
        try:
 
3276
            response = self._call(
 
3277
                'Branch.lock_write', self._remote_path(), branch_token,
 
3278
                repo_token or '', **err_context)
 
3279
        except errors.LockContention, e:
 
3280
            # The LockContention from the server doesn't have any
 
3281
            # information about the lock_url. We re-raise LockContention
 
3282
            # with valid lock_url.
 
3283
            raise errors.LockContention('(remote lock)',
 
3284
                self.repository.base.split('.bzr/')[0])
2411
3285
        if response[0] != 'ok':
2412
3286
            raise errors.UnexpectedSmartServerResponse(response)
2413
3287
        ok, branch_token, repo_token = response
2434
3308
            self._lock_mode = 'w'
2435
3309
            self._lock_count = 1
2436
3310
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3311
            raise errors.ReadOnlyError(self)
2438
3312
        else:
2439
3313
            if token is not None:
2440
3314
                # A token was given to lock_write, and we're relocking, so
2445
3319
            self._lock_count += 1
2446
3320
            # Re-lock the repository too.
2447
3321
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3322
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3323
 
2450
3324
    def _unlock(self, branch_token, repo_token):
2451
3325
        err_context = {'token': str((branch_token, repo_token))}
2489
3363
            self.repository.unlock()
2490
3364
 
2491
3365
    def break_lock(self):
2492
 
        self._ensure_real()
2493
 
        return self._real_branch.break_lock()
 
3366
        try:
 
3367
            response = self._call(
 
3368
                'Branch.break_lock', self._remote_path())
 
3369
        except errors.UnknownSmartMethod:
 
3370
            self._ensure_real()
 
3371
            return self._real_branch.break_lock()
 
3372
        if response != ('ok',):
 
3373
            raise errors.UnexpectedSmartServerResponse(response)
2494
3374
 
2495
3375
    def leave_lock_in_place(self):
2496
3376
        if not self._lock_token:
2520
3400
            missing_parent = parent_map[missing_parent]
2521
3401
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3402
 
2523
 
    def _last_revision_info(self):
 
3403
    def _read_last_revision_info(self):
2524
3404
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3405
        if response[0] != 'ok':
2526
3406
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3469
            raise errors.UnexpectedSmartServerResponse(response)
2590
3470
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3471
 
 
3472
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3473
    @needs_write_lock
2593
3474
    def set_revision_history(self, rev_history):
 
3475
        """See Branch.set_revision_history."""
 
3476
        self._set_revision_history(rev_history)
 
3477
 
 
3478
    @needs_write_lock
 
3479
    def _set_revision_history(self, rev_history):
2594
3480
        # Send just the tip revision of the history; the server will generate
2595
3481
        # the full history from that.  If the revision doesn't exist in this
2596
3482
        # branch, NoSuchRevision will be raised.
2654
3540
            _override_hook_target=self, **kwargs)
2655
3541
 
2656
3542
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3543
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3544
        self._ensure_real()
2659
3545
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3546
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3547
            _override_hook_source_branch=self)
2662
3548
 
2663
3549
    def is_locked(self):
2664
3550
        return self._lock_count >= 1
2665
3551
 
2666
3552
    @needs_read_lock
 
3553
    def revision_id_to_dotted_revno(self, revision_id):
 
3554
        """Given a revision id, return its dotted revno.
 
3555
 
 
3556
        :return: a tuple like (1,) or (400,1,3).
 
3557
        """
 
3558
        try:
 
3559
            response = self._call('Branch.revision_id_to_revno',
 
3560
                self._remote_path(), revision_id)
 
3561
        except errors.UnknownSmartMethod:
 
3562
            self._ensure_real()
 
3563
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3564
        if response[0] == 'ok':
 
3565
            return tuple([int(x) for x in response[1:]])
 
3566
        else:
 
3567
            raise errors.UnexpectedSmartServerResponse(response)
 
3568
 
 
3569
    @needs_read_lock
2667
3570
    def revision_id_to_revno(self, revision_id):
2668
 
        self._ensure_real()
2669
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3571
        """Given a revision id on the branch mainline, return its revno.
 
3572
 
 
3573
        :return: an integer
 
3574
        """
 
3575
        try:
 
3576
            response = self._call('Branch.revision_id_to_revno',
 
3577
                self._remote_path(), revision_id)
 
3578
        except errors.UnknownSmartMethod:
 
3579
            self._ensure_real()
 
3580
            return self._real_branch.revision_id_to_revno(revision_id)
 
3581
        if response[0] == 'ok':
 
3582
            if len(response) == 2:
 
3583
                return int(response[1])
 
3584
            raise NoSuchRevision(self, revision_id)
 
3585
        else:
 
3586
            raise errors.UnexpectedSmartServerResponse(response)
2670
3587
 
2671
3588
    @needs_write_lock
2672
3589
    def set_last_revision_info(self, revno, revision_id):
2673
3590
        # XXX: These should be returned by the set_last_revision_info verb
2674
3591
        old_revno, old_revid = self.last_revision_info()
2675
3592
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3593
        if not revision_id or not isinstance(revision_id, basestring):
 
3594
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3595
        try:
2678
3596
            response = self._call('Branch.set_last_revision_info',
2679
3597
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3626
            except errors.UnknownSmartMethod:
2709
3627
                medium._remember_remote_is_before((1, 6))
2710
3628
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3629
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3630
            last_rev=last_rev,other_branch=other_branch))
2713
3631
 
2714
3632
    def set_push_location(self, location):
2715
3633
        self._ensure_real()
2716
3634
        return self._real_branch.set_push_location(location)
2717
3635
 
 
3636
    def heads_to_fetch(self):
 
3637
        if self._format._use_default_local_heads_to_fetch():
 
3638
            # We recognise this format, and its heads-to-fetch implementation
 
3639
            # is the default one (tip + tags).  In this case it's cheaper to
 
3640
            # just use the default implementation rather than a special RPC as
 
3641
            # the tip and tags data is cached.
 
3642
            return branch.Branch.heads_to_fetch(self)
 
3643
        medium = self._client._medium
 
3644
        if medium._is_remote_before((2, 4)):
 
3645
            return self._vfs_heads_to_fetch()
 
3646
        try:
 
3647
            return self._rpc_heads_to_fetch()
 
3648
        except errors.UnknownSmartMethod:
 
3649
            medium._remember_remote_is_before((2, 4))
 
3650
            return self._vfs_heads_to_fetch()
 
3651
 
 
3652
    def _rpc_heads_to_fetch(self):
 
3653
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3654
        if len(response) != 2:
 
3655
            raise errors.UnexpectedSmartServerResponse(response)
 
3656
        must_fetch, if_present_fetch = response
 
3657
        return set(must_fetch), set(if_present_fetch)
 
3658
 
 
3659
    def _vfs_heads_to_fetch(self):
 
3660
        self._ensure_real()
 
3661
        return self._real_branch.heads_to_fetch()
 
3662
 
2718
3663
 
2719
3664
class RemoteConfig(object):
2720
3665
    """A Config that reads and writes from smart verbs.
2734
3679
        """
2735
3680
        try:
2736
3681
            configobj = self._get_configobj()
 
3682
            section_obj = None
2737
3683
            if section is None:
2738
3684
                section_obj = configobj
2739
3685
            else:
2740
3686
                try:
2741
3687
                    section_obj = configobj[section]
2742
3688
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3689
                    pass
 
3690
            if section_obj is None:
 
3691
                value = default
 
3692
            else:
 
3693
                value = section_obj.get(name, default)
2745
3694
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3695
            value = self._vfs_get_option(name, section, default)
 
3696
        for hook in config.OldConfigHooks['get']:
 
3697
            hook(self, name, value)
 
3698
        return value
2747
3699
 
2748
3700
    def _response_to_configobj(self, response):
2749
3701
        if len(response[0]) and response[0][0] != 'ok':
2750
3702
            raise errors.UnexpectedSmartServerResponse(response)
2751
3703
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3704
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3705
        for hook in config.OldConfigHooks['load']:
 
3706
            hook(self)
 
3707
        return conf
2753
3708
 
2754
3709
 
2755
3710
class RemoteBranchConfig(RemoteConfig):
2774
3729
        medium = self._branch._client._medium
2775
3730
        if medium._is_remote_before((1, 14)):
2776
3731
            return self._vfs_set_option(value, name, section)
 
3732
        if isinstance(value, dict):
 
3733
            if medium._is_remote_before((2, 2)):
 
3734
                return self._vfs_set_option(value, name, section)
 
3735
            return self._set_config_option_dict(value, name, section)
 
3736
        else:
 
3737
            return self._set_config_option(value, name, section)
 
3738
 
 
3739
    def _set_config_option(self, value, name, section):
2777
3740
        try:
2778
3741
            path = self._branch._remote_path()
2779
3742
            response = self._branch._client.call('Branch.set_config_option',
2780
3743
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3744
                value.encode('utf8'), name, section or '')
2782
3745
        except errors.UnknownSmartMethod:
 
3746
            medium = self._branch._client._medium
2783
3747
            medium._remember_remote_is_before((1, 14))
2784
3748
            return self._vfs_set_option(value, name, section)
2785
3749
        if response != ():
2786
3750
            raise errors.UnexpectedSmartServerResponse(response)
2787
3751
 
 
3752
    def _serialize_option_dict(self, option_dict):
 
3753
        utf8_dict = {}
 
3754
        for key, value in option_dict.items():
 
3755
            if isinstance(key, unicode):
 
3756
                key = key.encode('utf8')
 
3757
            if isinstance(value, unicode):
 
3758
                value = value.encode('utf8')
 
3759
            utf8_dict[key] = value
 
3760
        return bencode.bencode(utf8_dict)
 
3761
 
 
3762
    def _set_config_option_dict(self, value, name, section):
 
3763
        try:
 
3764
            path = self._branch._remote_path()
 
3765
            serialised_dict = self._serialize_option_dict(value)
 
3766
            response = self._branch._client.call(
 
3767
                'Branch.set_config_option_dict',
 
3768
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3769
                serialised_dict, name, section or '')
 
3770
        except errors.UnknownSmartMethod:
 
3771
            medium = self._branch._client._medium
 
3772
            medium._remember_remote_is_before((2, 2))
 
3773
            return self._vfs_set_option(value, name, section)
 
3774
        if response != ():
 
3775
            raise errors.UnexpectedSmartServerResponse(response)
 
3776
 
2788
3777
    def _real_object(self):
2789
3778
        self._branch._ensure_real()
2790
3779
        return self._branch._real_branch
2829
3818
        return self._bzrdir._real_bzrdir
2830
3819
 
2831
3820
 
2832
 
 
2833
3821
def _extract_tar(tar, to_dir):
2834
3822
    """Extract all the contents of a tarfile object.
2835
3823
 
2839
3827
        tar.extract(tarinfo, to_dir)
2840
3828
 
2841
3829
 
 
3830
error_translators = registry.Registry()
 
3831
no_context_error_translators = registry.Registry()
 
3832
 
 
3833
 
2842
3834
def _translate_error(err, **context):
2843
3835
    """Translate an ErrorFromSmartServer into a more useful error.
2844
3836
 
2873
3865
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3866
                raise err
2875
3867
 
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'):
 
3868
    try:
 
3869
        translator = error_translators.get(err.error_verb)
 
3870
    except KeyError:
 
3871
        pass
 
3872
    else:
 
3873
        raise translator(err, find, get_path)
 
3874
    try:
 
3875
        translator = no_context_error_translators.get(err.error_verb)
 
3876
    except KeyError:
 
3877
        raise errors.UnknownErrorFromSmartServer(err)
 
3878
    else:
 
3879
        raise translator(err)
 
3880
 
 
3881
 
 
3882
error_translators.register('NoSuchRevision',
 
3883
    lambda err, find, get_path: NoSuchRevision(
 
3884
        find('branch'), err.error_args[0]))
 
3885
error_translators.register('nosuchrevision',
 
3886
    lambda err, find, get_path: NoSuchRevision(
 
3887
        find('repository'), err.error_args[0]))
 
3888
 
 
3889
def _translate_nobranch_error(err, find, get_path):
 
3890
    if len(err.error_args) >= 1:
 
3891
        extra = err.error_args[0]
 
3892
    else:
 
3893
        extra = None
 
3894
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3895
        detail=extra)
 
3896
 
 
3897
error_translators.register('nobranch', _translate_nobranch_error)
 
3898
error_translators.register('norepository',
 
3899
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3900
        find('bzrdir')))
 
3901
error_translators.register('UnlockableTransport',
 
3902
    lambda err, find, get_path: errors.UnlockableTransport(
 
3903
        find('bzrdir').root_transport))
 
3904
error_translators.register('TokenMismatch',
 
3905
    lambda err, find, get_path: errors.TokenMismatch(
 
3906
        find('token'), '(remote token)'))
 
3907
error_translators.register('Diverged',
 
3908
    lambda err, find, get_path: errors.DivergedBranches(
 
3909
        find('branch'), find('other_branch')))
 
3910
error_translators.register('NotStacked',
 
3911
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3912
 
 
3913
def _translate_PermissionDenied(err, find, get_path):
 
3914
    path = get_path()
 
3915
    if len(err.error_args) >= 2:
 
3916
        extra = err.error_args[1]
 
3917
    else:
 
3918
        extra = None
 
3919
    return errors.PermissionDenied(path, extra=extra)
 
3920
 
 
3921
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3922
error_translators.register('ReadError',
 
3923
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3924
error_translators.register('NoSuchFile',
 
3925
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3926
error_translators.register('UnsuspendableWriteGroup',
 
3927
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3928
        repository=find('repository')))
 
3929
error_translators.register('UnresumableWriteGroup',
 
3930
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3931
        repository=find('repository'), write_groups=err.error_args[0],
 
3932
        reason=err.error_args[1]))
 
3933
no_context_error_translators.register('IncompatibleRepositories',
 
3934
    lambda err: errors.IncompatibleRepositories(
 
3935
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3936
no_context_error_translators.register('LockContention',
 
3937
    lambda err: errors.LockContention('(remote lock)'))
 
3938
no_context_error_translators.register('LockFailed',
 
3939
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3940
no_context_error_translators.register('TipChangeRejected',
 
3941
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
3942
no_context_error_translators.register('UnstackableBranchFormat',
 
3943
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
3944
no_context_error_translators.register('UnstackableRepositoryFormat',
 
3945
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
3946
no_context_error_translators.register('FileExists',
 
3947
    lambda err: errors.FileExists(err.error_args[0]))
 
3948
no_context_error_translators.register('DirectoryNotEmpty',
 
3949
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
3950
 
 
3951
def _translate_short_readv_error(err):
 
3952
    args = err.error_args
 
3953
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
3954
        int(args[3]))
 
3955
 
 
3956
no_context_error_translators.register('ShortReadvError',
 
3957
    _translate_short_readv_error)
 
3958
 
 
3959
def _translate_unicode_error(err):
2932
3960
        encoding = str(err.error_args[0]) # encoding must always be a string
2933
3961
        val = err.error_args[1]
2934
3962
        start = int(err.error_args[2])
2942
3970
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2943
3971
        elif err.error_verb == 'UnicodeEncodeError':
2944
3972
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
 
    elif err.error_verb == 'ReadOnlyError':
2946
 
        raise errors.TransportNotPossible('readonly transport')
2947
 
    raise errors.UnknownErrorFromSmartServer(err)
 
3973
 
 
3974
no_context_error_translators.register('UnicodeEncodeError',
 
3975
    _translate_unicode_error)
 
3976
no_context_error_translators.register('UnicodeDecodeError',
 
3977
    _translate_unicode_error)
 
3978
no_context_error_translators.register('ReadOnlyError',
 
3979
    lambda err: errors.TransportNotPossible('readonly transport'))
 
3980
no_context_error_translators.register('MemoryError',
 
3981
    lambda err: errors.BzrError("remote server out of memory\n"
 
3982
        "Retry non-remotely, or contact the server admin for details."))
 
3983
no_context_error_translators.register('RevisionNotPresent',
 
3984
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
3985
 
 
3986
no_context_error_translators.register('BzrCheckError',
 
3987
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
3988