/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-14 12:25:34 UTC
  • mto: (6282.6.42 hpss-get-inventories)
  • mto: This revision was merged to the branch mainline in revision 6371.
  • Revision ID: jelmer@samba.org-20111214122534-5ot01rv7miypacmf
More documentation.

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
    vf_search,
 
42
    )
 
43
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
44
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
45
from bzrlib.errors import (
40
46
    NoSuchRevision,
41
47
    SmartProtocolError,
42
48
    )
 
49
from bzrlib.i18n import gettext
 
50
from bzrlib.inventory import Inventory
43
51
from bzrlib.lockable_files import LockableFiles
44
52
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.trace import mutter, note, warning
 
53
from bzrlib.smart.client import _SmartClient
 
54
from bzrlib.revision import NULL_REVISION
 
55
from bzrlib.revisiontree import InventoryRevisionTree
 
56
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
57
from bzrlib.serializer import format_registry as serializer_format_registry
 
58
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
59
 
 
60
 
 
61
_DEFAULT_SEARCH_DEPTH = 100
47
62
 
48
63
 
49
64
class _RpcHelper(object):
86
101
    return format
87
102
 
88
103
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
104
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
105
# does not have to be imported unless a remote format is involved.
 
106
 
 
107
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
108
    """Format representing bzrdirs accessed via a smart server"""
 
109
 
 
110
    supports_workingtrees = False
 
111
 
 
112
    def __init__(self):
 
113
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
114
        # XXX: It's a bit ugly that the network name is here, because we'd
 
115
        # like to believe that format objects are stateless or at least
 
116
        # immutable,  However, we do at least avoid mutating the name after
 
117
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
118
        self._network_name = None
 
119
 
 
120
    def __repr__(self):
 
121
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
122
            self._network_name)
 
123
 
 
124
    def get_format_description(self):
 
125
        if self._network_name:
 
126
            try:
 
127
                real_format = controldir.network_format_registry.get(
 
128
                        self._network_name)
 
129
            except KeyError:
 
130
                pass
 
131
            else:
 
132
                return 'Remote: ' + real_format.get_format_description()
 
133
        return 'bzr remote bzrdir'
 
134
 
 
135
    def get_format_string(self):
 
136
        raise NotImplementedError(self.get_format_string)
 
137
 
 
138
    def network_name(self):
 
139
        if self._network_name:
 
140
            return self._network_name
 
141
        else:
 
142
            raise AssertionError("No network name set.")
 
143
 
 
144
    def initialize_on_transport(self, transport):
 
145
        try:
 
146
            # hand off the request to the smart server
 
147
            client_medium = transport.get_smart_medium()
 
148
        except errors.NoSmartMedium:
 
149
            # TODO: lookup the local format from a server hint.
 
150
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
151
            return local_dir_format.initialize_on_transport(transport)
 
152
        client = _SmartClient(client_medium)
 
153
        path = client.remote_path_from_transport(transport)
 
154
        try:
 
155
            response = client.call('BzrDirFormat.initialize', path)
 
156
        except errors.ErrorFromSmartServer, err:
 
157
            _translate_error(err, path=path)
 
158
        if response[0] != 'ok':
 
159
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
160
        format = RemoteBzrDirFormat()
 
161
        self._supply_sub_formats_to(format)
 
162
        return RemoteBzrDir(transport, format)
 
163
 
 
164
    def parse_NoneTrueFalse(self, arg):
 
165
        if not arg:
 
166
            return None
 
167
        if arg == 'False':
 
168
            return False
 
169
        if arg == 'True':
 
170
            return True
 
171
        raise AssertionError("invalid arg %r" % arg)
 
172
 
 
173
    def _serialize_NoneTrueFalse(self, arg):
 
174
        if arg is False:
 
175
            return 'False'
 
176
        if arg:
 
177
            return 'True'
 
178
        return ''
 
179
 
 
180
    def _serialize_NoneString(self, arg):
 
181
        return arg or ''
 
182
 
 
183
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
184
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
185
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
186
        shared_repo=False):
 
187
        try:
 
188
            # hand off the request to the smart server
 
189
            client_medium = transport.get_smart_medium()
 
190
        except errors.NoSmartMedium:
 
191
            do_vfs = True
 
192
        else:
 
193
            # Decline to open it if the server doesn't support our required
 
194
            # version (3) so that the VFS-based transport will do it.
 
195
            if client_medium.should_probe():
 
196
                try:
 
197
                    server_version = client_medium.protocol_version()
 
198
                    if server_version != '2':
 
199
                        do_vfs = True
 
200
                    else:
 
201
                        do_vfs = False
 
202
                except errors.SmartProtocolError:
 
203
                    # Apparently there's no usable smart server there, even though
 
204
                    # the medium supports the smart protocol.
 
205
                    do_vfs = True
 
206
            else:
 
207
                do_vfs = False
 
208
        if not do_vfs:
 
209
            client = _SmartClient(client_medium)
 
210
            path = client.remote_path_from_transport(transport)
 
211
            if client_medium._is_remote_before((1, 16)):
 
212
                do_vfs = True
 
213
        if do_vfs:
 
214
            # TODO: lookup the local format from a server hint.
 
215
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
216
            self._supply_sub_formats_to(local_dir_format)
 
217
            return local_dir_format.initialize_on_transport_ex(transport,
 
218
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
219
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
220
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
221
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
222
                vfs_only=True)
 
223
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
224
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
225
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
226
 
 
227
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
228
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
229
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
230
        args = []
 
231
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
232
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
233
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
234
        args.append(self._serialize_NoneString(stacked_on))
 
235
        # stack_on_pwd is often/usually our transport
 
236
        if stack_on_pwd:
 
237
            try:
 
238
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
239
                if not stack_on_pwd:
 
240
                    stack_on_pwd = '.'
 
241
            except errors.PathNotChild:
 
242
                pass
 
243
        args.append(self._serialize_NoneString(stack_on_pwd))
 
244
        args.append(self._serialize_NoneString(repo_format_name))
 
245
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
246
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
247
        request_network_name = self._network_name or \
 
248
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
249
        try:
 
250
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
251
                request_network_name, path, *args)
 
252
        except errors.UnknownSmartMethod:
 
253
            client._medium._remember_remote_is_before((1,16))
 
254
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
255
            self._supply_sub_formats_to(local_dir_format)
 
256
            return local_dir_format.initialize_on_transport_ex(transport,
 
257
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
258
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
259
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
260
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
261
                vfs_only=True)
 
262
        except errors.ErrorFromSmartServer, err:
 
263
            _translate_error(err, path=path)
 
264
        repo_path = response[0]
 
265
        bzrdir_name = response[6]
 
266
        require_stacking = response[7]
 
267
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
268
        format = RemoteBzrDirFormat()
 
269
        format._network_name = bzrdir_name
 
270
        self._supply_sub_formats_to(format)
 
271
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
272
        if repo_path:
 
273
            repo_format = response_tuple_to_repo_format(response[1:])
 
274
            if repo_path == '.':
 
275
                repo_path = ''
 
276
            if repo_path:
 
277
                repo_bzrdir_format = RemoteBzrDirFormat()
 
278
                repo_bzrdir_format._network_name = response[5]
 
279
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
280
                    repo_bzrdir_format)
 
281
            else:
 
282
                repo_bzr = bzrdir
 
283
            final_stack = response[8] or None
 
284
            final_stack_pwd = response[9] or None
 
285
            if final_stack_pwd:
 
286
                final_stack_pwd = urlutils.join(
 
287
                    transport.base, final_stack_pwd)
 
288
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
289
            if len(response) > 10:
 
290
                # Updated server verb that locks remotely.
 
291
                repo_lock_token = response[10] or None
 
292
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
293
                if repo_lock_token:
 
294
                    remote_repo.dont_leave_lock_in_place()
 
295
            else:
 
296
                remote_repo.lock_write()
 
297
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
298
                final_stack_pwd, require_stacking)
 
299
            policy.acquire_repository()
 
300
        else:
 
301
            remote_repo = None
 
302
            policy = None
 
303
        bzrdir._format.set_branch_format(self.get_branch_format())
 
304
        if require_stacking:
 
305
            # The repo has already been created, but we need to make sure that
 
306
            # we'll make a stackable branch.
 
307
            bzrdir._format.require_stacking(_skip_repo=True)
 
308
        return remote_repo, bzrdir, require_stacking, policy
 
309
 
 
310
    def _open(self, transport):
 
311
        return RemoteBzrDir(transport, self)
 
312
 
 
313
    def __eq__(self, other):
 
314
        if not isinstance(other, RemoteBzrDirFormat):
 
315
            return False
 
316
        return self.get_format_description() == other.get_format_description()
 
317
 
 
318
    def __return_repository_format(self):
 
319
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
320
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
321
        # that it should use that for init() etc.
 
322
        result = RemoteRepositoryFormat()
 
323
        custom_format = getattr(self, '_repository_format', None)
 
324
        if custom_format:
 
325
            if isinstance(custom_format, RemoteRepositoryFormat):
 
326
                return custom_format
 
327
            else:
 
328
                # We will use the custom format to create repositories over the
 
329
                # wire; expose its details like rich_root_data for code to
 
330
                # query
 
331
                result._custom_format = custom_format
 
332
        return result
 
333
 
 
334
    def get_branch_format(self):
 
335
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
336
        if not isinstance(result, RemoteBranchFormat):
 
337
            new_result = RemoteBranchFormat()
 
338
            new_result._custom_format = result
 
339
            # cache the result
 
340
            self.set_branch_format(new_result)
 
341
            result = new_result
 
342
        return result
 
343
 
 
344
    repository_format = property(__return_repository_format,
 
345
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
346
 
 
347
 
 
348
class RemoteControlStore(config.IniFileStore):
 
349
    """Control store which attempts to use HPSS calls to retrieve control store.
 
350
 
 
351
    Note that this is specific to bzr-based formats.
 
352
    """
 
353
 
 
354
    def __init__(self, bzrdir):
 
355
        super(RemoteControlStore, self).__init__()
 
356
        self.bzrdir = bzrdir
 
357
        self._real_store = None
 
358
 
 
359
    def lock_write(self, token=None):
 
360
        self._ensure_real()
 
361
        return self._real_store.lock_write(token)
 
362
 
 
363
    def unlock(self):
 
364
        self._ensure_real()
 
365
        return self._real_store.unlock()
 
366
 
 
367
    @needs_write_lock
 
368
    def save(self):
 
369
        # We need to be able to override the undecorated implementation
 
370
        self.save_without_locking()
 
371
 
 
372
    def save_without_locking(self):
 
373
        super(RemoteControlStore, self).save()
 
374
 
 
375
    def _ensure_real(self):
 
376
        self.bzrdir._ensure_real()
 
377
        if self._real_store is None:
 
378
            self._real_store = config.ControlStore(self.bzrdir)
 
379
 
 
380
    def external_url(self):
 
381
        return self.bzrdir.user_url
 
382
 
 
383
    def _load_content(self):
 
384
        medium = self.bzrdir._client._medium
 
385
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
386
        try:
 
387
            response, handler = self.bzrdir._call_expecting_body(
 
388
                'BzrDir.get_config_file', path)
 
389
        except errors.UnknownSmartMethod:
 
390
            self._ensure_real()
 
391
            return self._real_store._load_content()
 
392
        if len(response) and response[0] != 'ok':
 
393
            raise errors.UnexpectedSmartServerResponse(response)
 
394
        return handler.read_body_bytes()
 
395
 
 
396
    def _save_content(self, content):
 
397
        # FIXME JRV 2011-11-22: Ideally this should use a
 
398
        # HPSS call too, but at the moment it is not possible
 
399
        # to write lock control directories.
 
400
        self._ensure_real()
 
401
        return self._real_store._save_content(content)
 
402
 
 
403
 
 
404
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
405
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
406
 
94
407
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
410
        :param _client: Private parameter for testing. Disables probing and the
98
411
            use of a real bzrdir.
99
412
        """
100
 
        BzrDir.__init__(self, transport, format)
 
413
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
414
        # this object holds a delegated bzrdir that uses file-level operations
102
415
        # to talk to the other side
103
416
        self._real_bzrdir = None
163
476
                import traceback
164
477
                warning('VFS BzrDir access triggered\n%s',
165
478
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
479
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
480
                self.root_transport, _server_formats=False)
168
481
            self._format._network_name = \
169
482
                self._real_bzrdir._format.network_name()
175
488
        # Prevent aliasing problems in the next_open_branch_result cache.
176
489
        # See create_branch for rationale.
177
490
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
491
        return _mod_bzrdir.BzrDir.break_lock(self)
 
492
 
 
493
    def _vfs_checkout_metadir(self):
 
494
        self._ensure_real()
 
495
        return self._real_bzrdir.checkout_metadir()
 
496
 
 
497
    def checkout_metadir(self):
 
498
        medium = self._client._medium
 
499
        if medium._is_remote_before((2, 5)):
 
500
            return self._vfs_checkout_metadir()
 
501
        path = self._path_for_remote_call(self._client)
 
502
        try:
 
503
            response = self._client.call('BzrDir.checkout_metadir',
 
504
                path)
 
505
        except errors.UnknownSmartMethod:
 
506
            medium._remember_remote_is_before((2, 5))
 
507
            return self._vfs_checkout_metadir()
 
508
        if len(response) != 3:
 
509
            raise errors.UnexpectedSmartServerResponse(response)
 
510
        control_name, repo_name, branch_name = response
 
511
        try:
 
512
            format = controldir.network_format_registry.get(control_name)
 
513
        except KeyError:
 
514
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
515
        if repo_name:
 
516
            try:
 
517
                repo_format = _mod_repository.network_format_registry.get(
 
518
                    repo_name)
 
519
            except KeyError:
 
520
                raise errors.UnknownFormatError(kind='repository',
 
521
                    format=repo_name)
 
522
            format.repository_format = repo_format
 
523
        if branch_name:
 
524
            try:
 
525
                format.set_branch_format(
 
526
                    branch.network_format_registry.get(branch_name))
 
527
            except KeyError:
 
528
                raise errors.UnknownFormatError(kind='branch',
 
529
                    format=branch_name)
 
530
        return format
179
531
 
180
532
    def _vfs_cloning_metadir(self, require_stacking=False):
181
533
        self._ensure_real()
212
564
        if len(branch_info) != 2:
213
565
            raise errors.UnexpectedSmartServerResponse(response)
214
566
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
567
        try:
 
568
            format = controldir.network_format_registry.get(control_name)
 
569
        except KeyError:
 
570
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
571
 
216
572
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
218
 
                repo_name)
 
573
            try:
 
574
                format.repository_format = _mod_repository.network_format_registry.get(
 
575
                    repo_name)
 
576
            except KeyError:
 
577
                raise errors.UnknownFormatError(kind='repository',
 
578
                    format=repo_name)
219
579
        if branch_ref == 'ref':
220
580
            # XXX: we need possible_transports here to avoid reopening the
221
581
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
582
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
583
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
584
            format.set_branch_format(branch_format)
225
585
        elif branch_ref == 'branch':
226
586
            if branch_name:
227
 
                format.set_branch_format(
228
 
                    branch.network_format_registry.get(branch_name))
 
587
                try:
 
588
                    branch_format = branch.network_format_registry.get(
 
589
                        branch_name)
 
590
                except KeyError:
 
591
                    raise errors.UnknownFormatError(kind='branch',
 
592
                        format=branch_name)
 
593
                format.set_branch_format(branch_format)
229
594
        else:
230
595
            raise errors.UnexpectedSmartServerResponse(response)
231
596
        return format
241
606
 
242
607
    def destroy_repository(self):
243
608
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
609
        path = self._path_for_remote_call(self._client)
 
610
        try:
 
611
            response = self._call('BzrDir.destroy_repository', path)
 
612
        except errors.UnknownSmartMethod:
 
613
            self._ensure_real()
 
614
            self._real_bzrdir.destroy_repository()
 
615
            return
 
616
        if response[0] != 'ok':
 
617
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
618
 
247
 
    def create_branch(self, name=None):
 
619
    def create_branch(self, name=None, repository=None,
 
620
                      append_revisions_only=None):
248
621
        # as per meta1 formats - just delegate to the format object which may
249
622
        # be parameterised.
250
623
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
624
            name=name, repository=repository,
 
625
            append_revisions_only=append_revisions_only)
252
626
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
627
            if not isinstance(repository, RemoteRepository):
 
628
                raise AssertionError(
 
629
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
630
                    % (repository,))
 
631
            result = RemoteBranch(self, repository, real_branch, name=name)
255
632
        else:
256
633
            result = real_branch
257
634
        # BzrDir.clone_on_transport() uses the result of create_branch but does
265
642
 
266
643
    def destroy_branch(self, name=None):
267
644
        """See BzrDir.destroy_branch"""
268
 
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
645
        path = self._path_for_remote_call(self._client)
 
646
        try:
 
647
            if name is not None:
 
648
                args = (name, )
 
649
            else:
 
650
                args = ()
 
651
            response = self._call('BzrDir.destroy_branch', path, *args)
 
652
        except errors.UnknownSmartMethod:
 
653
            self._ensure_real()
 
654
            self._real_bzrdir.destroy_branch(name=name)
 
655
            self._next_open_branch_result = None
 
656
            return
270
657
        self._next_open_branch_result = None
 
658
        if response[0] != 'ok':
 
659
            raise SmartProtocolError('unexpected response code %s' % (response,))
271
660
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
661
    def create_workingtree(self, revision_id=None, from_branch=None,
 
662
        accelerator_tree=None, hardlink=False):
273
663
        raise errors.NotLocalUrl(self.transport.base)
274
664
 
275
 
    def find_branch_format(self):
 
665
    def find_branch_format(self, name=None):
276
666
        """Find the branch 'format' for this bzrdir.
277
667
 
278
668
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
669
        """
280
 
        b = self.open_branch()
 
670
        b = self.open_branch(name=name)
281
671
        return b._format
282
672
 
283
 
    def get_branch_reference(self):
 
673
    def get_branch_reference(self, name=None):
284
674
        """See BzrDir.get_branch_reference()."""
 
675
        if name is not None:
 
676
            # XXX JRV20100304: Support opening colocated branches
 
677
            raise errors.NoColocatedBranchSupport(self)
285
678
        response = self._get_branch_reference()
286
679
        if response[0] == 'ref':
287
680
            return response[1]
318
711
            raise errors.UnexpectedSmartServerResponse(response)
319
712
        return response
320
713
 
321
 
    def _get_tree_branch(self):
 
714
    def _get_tree_branch(self, name=None):
322
715
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
716
        return None, self.open_branch(name=name)
324
717
 
325
718
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
 
719
                    ignore_fallbacks=False, possible_transports=None):
327
720
        if unsupported:
328
721
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
722
        if self._next_open_branch_result is not None:
336
729
            # a branch reference, use the existing BranchReference logic.
337
730
            format = BranchReferenceFormat()
338
731
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
732
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
733
                possible_transports=possible_transports)
340
734
        branch_format_name = response[1]
341
735
        if not branch_format_name:
342
736
            branch_format_name = None
343
737
        format = RemoteBranchFormat(network_name=branch_format_name)
344
738
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
 
739
            setup_stacking=not ignore_fallbacks, name=name,
 
740
            possible_transports=possible_transports)
346
741
 
347
742
    def _open_repo_v1(self, path):
348
743
        verb = 'BzrDir.find_repository'
411
806
 
412
807
    def has_workingtree(self):
413
808
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
809
            path = self._path_for_remote_call(self._client)
 
810
            try:
 
811
                response = self._call('BzrDir.has_workingtree', path)
 
812
            except errors.UnknownSmartMethod:
 
813
                self._ensure_real()
 
814
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
815
            else:
 
816
                if response[0] not in ('yes', 'no'):
 
817
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
818
                self._has_working_tree = (response[0] == 'yes')
416
819
        return self._has_working_tree
417
820
 
418
821
    def open_workingtree(self, recommend_upgrade=True):
423
826
 
424
827
    def _path_for_remote_call(self, client):
425
828
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
829
        return urlutils.split_segment_parameters_raw(
 
830
            client.remote_path_from_transport(self.root_transport))[0]
427
831
 
428
832
    def get_branch_transport(self, branch_format, name=None):
429
833
        self._ensure_real()
441
845
        """Upgrading of remote bzrdirs is not supported yet."""
442
846
        return False
443
847
 
444
 
    def needs_format_conversion(self, format=None):
 
848
    def needs_format_conversion(self, format):
445
849
        """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
850
        return False
450
851
 
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
852
    def _get_config(self):
458
853
        return RemoteBzrDirConfig(self)
459
854
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
855
    def _get_config_store(self):
 
856
        return RemoteControlStore(self)
 
857
 
 
858
 
 
859
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
860
    """Format for repositories accessed over a _SmartClient.
463
861
 
464
862
    Instances of this repository are represented by RemoteRepository
479
877
    """
480
878
 
481
879
    _matchingbzrdir = RemoteBzrDirFormat()
 
880
    supports_full_versioned_files = True
 
881
    supports_leaving_lock = True
482
882
 
483
883
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
884
        _mod_repository.RepositoryFormat.__init__(self)
485
885
        self._custom_format = None
486
886
        self._network_name = None
487
887
        self._creating_bzrdir = None
 
888
        self._revision_graph_can_have_wrong_parents = None
488
889
        self._supports_chks = None
489
890
        self._supports_external_lookups = None
490
891
        self._supports_tree_reference = None
 
892
        self._supports_funky_characters = None
 
893
        self._supports_nesting_repositories = None
491
894
        self._rich_root_data = None
492
895
 
493
896
    def __repr__(self):
522
925
        return self._supports_external_lookups
523
926
 
524
927
    @property
 
928
    def supports_funky_characters(self):
 
929
        if self._supports_funky_characters is None:
 
930
            self._ensure_real()
 
931
            self._supports_funky_characters = \
 
932
                self._custom_format.supports_funky_characters
 
933
        return self._supports_funky_characters
 
934
 
 
935
    @property
 
936
    def supports_nesting_repositories(self):
 
937
        if self._supports_nesting_repositories is None:
 
938
            self._ensure_real()
 
939
            self._supports_nesting_repositories = \
 
940
                self._custom_format.supports_nesting_repositories
 
941
        return self._supports_nesting_repositories
 
942
 
 
943
    @property
525
944
    def supports_tree_reference(self):
526
945
        if self._supports_tree_reference is None:
527
946
            self._ensure_real()
529
948
                self._custom_format.supports_tree_reference
530
949
        return self._supports_tree_reference
531
950
 
 
951
    @property
 
952
    def revision_graph_can_have_wrong_parents(self):
 
953
        if self._revision_graph_can_have_wrong_parents is None:
 
954
            self._ensure_real()
 
955
            self._revision_graph_can_have_wrong_parents = \
 
956
                self._custom_format.revision_graph_can_have_wrong_parents
 
957
        return self._revision_graph_can_have_wrong_parents
 
958
 
532
959
    def _vfs_initialize(self, a_bzrdir, shared):
533
960
        """Helper for common code in initialize."""
534
961
        if self._custom_format:
569
996
            network_name = self._network_name
570
997
        else:
571
998
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
999
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
1000
            reference_format = reference_bzrdir_format.repository_format
574
1001
            network_name = reference_format.network_name()
575
1002
        # 2) try direct creation via RPC
601
1028
 
602
1029
    def _ensure_real(self):
603
1030
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
605
 
                self._network_name)
 
1031
            try:
 
1032
                self._custom_format = _mod_repository.network_format_registry.get(
 
1033
                    self._network_name)
 
1034
            except KeyError:
 
1035
                raise errors.UnknownFormatError(kind='repository',
 
1036
                    format=self._network_name)
606
1037
 
607
1038
    @property
608
1039
    def _fetch_order(self):
643
1074
        return self._custom_format._serializer
644
1075
 
645
1076
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1077
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1078
        lock._RelockDebugMixin):
648
1079
    """Repository accessed over rpc.
649
1080
 
650
1081
    For the moment most operations are performed using local transport-backed
674
1105
        self._format = format
675
1106
        self._lock_mode = None
676
1107
        self._lock_token = None
 
1108
        self._write_group_tokens = None
677
1109
        self._lock_count = 0
678
1110
        self._leave_lock = False
679
1111
        # Cache of revision parents; misses are cached during read locks, and
703
1135
        # transport, but I'm not sure it's worth making this method
704
1136
        # optional -- mbp 2010-04-21
705
1137
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1138
 
707
1139
    def __str__(self):
708
1140
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1141
 
719
1151
 
720
1152
        :param suppress_errors: see Repository.abort_write_group.
721
1153
        """
722
 
        self._ensure_real()
723
 
        return self._real_repository.abort_write_group(
724
 
            suppress_errors=suppress_errors)
 
1154
        if self._real_repository:
 
1155
            self._ensure_real()
 
1156
            return self._real_repository.abort_write_group(
 
1157
                suppress_errors=suppress_errors)
 
1158
        if not self.is_in_write_group():
 
1159
            if suppress_errors:
 
1160
                mutter('(suppressed) not in write group')
 
1161
                return
 
1162
            raise errors.BzrError("not in write group")
 
1163
        path = self.bzrdir._path_for_remote_call(self._client)
 
1164
        try:
 
1165
            response = self._call('Repository.abort_write_group', path,
 
1166
                self._lock_token, self._write_group_tokens)
 
1167
        except Exception, exc:
 
1168
            self._write_group = None
 
1169
            if not suppress_errors:
 
1170
                raise
 
1171
            mutter('abort_write_group failed')
 
1172
            log_exception_quietly()
 
1173
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1174
        else:
 
1175
            if response != ('ok', ):
 
1176
                raise errors.UnexpectedSmartServerResponse(response)
 
1177
            self._write_group_tokens = None
725
1178
 
726
1179
    @property
727
1180
    def chk_bytes(self):
741
1194
        for older plugins that don't use e.g. the CommitBuilder
742
1195
        facility.
743
1196
        """
744
 
        self._ensure_real()
745
 
        return self._real_repository.commit_write_group()
 
1197
        if self._real_repository:
 
1198
            self._ensure_real()
 
1199
            return self._real_repository.commit_write_group()
 
1200
        if not self.is_in_write_group():
 
1201
            raise errors.BzrError("not in write group")
 
1202
        path = self.bzrdir._path_for_remote_call(self._client)
 
1203
        response = self._call('Repository.commit_write_group', path,
 
1204
            self._lock_token, self._write_group_tokens)
 
1205
        if response != ('ok', ):
 
1206
            raise errors.UnexpectedSmartServerResponse(response)
 
1207
        self._write_group_tokens = None
746
1208
 
747
1209
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
 
1210
        if self._real_repository:
 
1211
            return self._real_repository.resume_write_group(tokens)
 
1212
        path = self.bzrdir._path_for_remote_call(self._client)
 
1213
        try:
 
1214
            response = self._call('Repository.check_write_group', path,
 
1215
               self._lock_token, tokens)
 
1216
        except errors.UnknownSmartMethod:
 
1217
            self._ensure_real()
 
1218
            return self._real_repository.resume_write_group(tokens)
 
1219
        if response != ('ok', ):
 
1220
            raise errors.UnexpectedSmartServerResponse(response)
 
1221
        self._write_group_tokens = tokens
750
1222
 
751
1223
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
 
1224
        if self._real_repository:
 
1225
            return self._real_repository.suspend_write_group()
 
1226
        ret = self._write_group_tokens or []
 
1227
        self._write_group_tokens = None
 
1228
        return ret
754
1229
 
755
1230
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
1231
        self._ensure_real()
817
1292
    def find_text_key_references(self):
818
1293
        """Find the text key references within the repository.
819
1294
 
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
1295
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1296
            to whether they were referred to by the inventory of the
825
1297
            revision_id that they contain. The inventory texts from all present
843
1315
        """Private method for using with old (< 1.2) servers to fallback."""
844
1316
        if revision_id is None:
845
1317
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1318
        elif _mod_revision.is_null(revision_id):
847
1319
            return {}
848
1320
 
849
1321
        path = self.bzrdir._path_for_remote_call(self._client)
873
1345
        return RemoteStreamSource(self, to_format)
874
1346
 
875
1347
    @needs_read_lock
 
1348
    def get_file_graph(self):
 
1349
        return graph.Graph(self.texts)
 
1350
 
 
1351
    @needs_read_lock
876
1352
    def has_revision(self, revision_id):
877
1353
        """True if this repository has a copy of the revision."""
878
1354
        # Copy of bzrlib.repository.Repository.has_revision
895
1371
    def _has_same_fallbacks(self, other_repo):
896
1372
        """Returns true if the repositories have the same fallbacks."""
897
1373
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1374
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1375
        my_fb = self._fallback_repositories
900
1376
        other_fb = other_repo._fallback_repositories
901
1377
        if len(my_fb) != len(other_fb):
930
1406
        """See Repository.gather_stats()."""
931
1407
        path = self.bzrdir._path_for_remote_call(self._client)
932
1408
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1409
        if revid is None or _mod_revision.is_null(revid):
934
1410
            fmt_revid = ''
935
1411
        else:
936
1412
            fmt_revid = revid
965
1441
 
966
1442
    def get_physical_lock_status(self):
967
1443
        """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()
 
1444
        path = self.bzrdir._path_for_remote_call(self._client)
 
1445
        try:
 
1446
            response = self._call('Repository.get_physical_lock_status', path)
 
1447
        except errors.UnknownSmartMethod:
 
1448
            self._ensure_real()
 
1449
            return self._real_repository.get_physical_lock_status()
 
1450
        if response[0] not in ('yes', 'no'):
 
1451
            raise errors.UnexpectedSmartServerResponse(response)
 
1452
        return (response[0] == 'yes')
971
1453
 
972
1454
    def is_in_write_group(self):
973
1455
        """Return True if there is an open write group.
974
1456
 
975
1457
        write groups are only applicable locally for the smart server..
976
1458
        """
 
1459
        if self._write_group_tokens is not None:
 
1460
            return True
977
1461
        if self._real_repository:
978
1462
            return self._real_repository.is_in_write_group()
979
1463
 
997
1481
        pass
998
1482
 
999
1483
    def lock_read(self):
 
1484
        """Lock the repository for read operations.
 
1485
 
 
1486
        :return: A bzrlib.lock.LogicalLockResult.
 
1487
        """
1000
1488
        # wrong eventually - want a local lock cache context
1001
1489
        if not self._lock_mode:
1002
1490
            self._note_lock('r')
1009
1497
                repo.lock_read()
1010
1498
        else:
1011
1499
            self._lock_count += 1
 
1500
        return lock.LogicalLockResult(self.unlock)
1012
1501
 
1013
1502
    def _remote_lock_write(self, token):
1014
1503
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1543
            raise errors.ReadOnlyError(self)
1055
1544
        else:
1056
1545
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1546
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1547
 
1059
1548
    def leave_lock_in_place(self):
1060
1549
        if not self._lock_token:
1109
1598
            self._real_repository.lock_write(self._lock_token)
1110
1599
        elif self._lock_mode == 'r':
1111
1600
            self._real_repository.lock_read()
 
1601
        if self._write_group_tokens is not None:
 
1602
            # if we are already in a write group, resume it
 
1603
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1604
            self._write_group_tokens = None
1112
1605
 
1113
1606
    def start_write_group(self):
1114
1607
        """Start a write group on the decorated repository.
1118
1611
        for older plugins that don't use e.g. the CommitBuilder
1119
1612
        facility.
1120
1613
        """
1121
 
        self._ensure_real()
1122
 
        return self._real_repository.start_write_group()
 
1614
        if self._real_repository:
 
1615
            self._ensure_real()
 
1616
            return self._real_repository.start_write_group()
 
1617
        if not self.is_write_locked():
 
1618
            raise errors.NotWriteLocked(self)
 
1619
        if self._write_group_tokens is not None:
 
1620
            raise errors.BzrError('already in a write group')
 
1621
        path = self.bzrdir._path_for_remote_call(self._client)
 
1622
        try:
 
1623
            response = self._call('Repository.start_write_group', path,
 
1624
                self._lock_token)
 
1625
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1626
            self._ensure_real()
 
1627
            return self._real_repository.start_write_group()
 
1628
        if response[0] != 'ok':
 
1629
            raise errors.UnexpectedSmartServerResponse(response)
 
1630
        self._write_group_tokens = response[1]
1123
1631
 
1124
1632
    def _unlock(self, token):
1125
1633
        path = self.bzrdir._path_for_remote_call(self._client)
1152
1660
            # This is just to let the _real_repository stay up to date.
1153
1661
            if self._real_repository is not None:
1154
1662
                self._real_repository.unlock()
 
1663
            elif self._write_group_tokens is not None:
 
1664
                self.abort_write_group()
1155
1665
        finally:
1156
1666
            # The rpc-level lock should be released even if there was a
1157
1667
            # problem releasing the vfs-based lock.
1169
1679
 
1170
1680
    def break_lock(self):
1171
1681
        # should hand off to the network
1172
 
        self._ensure_real()
1173
 
        return self._real_repository.break_lock()
 
1682
        path = self.bzrdir._path_for_remote_call(self._client)
 
1683
        try:
 
1684
            response = self._call("Repository.break_lock", path)
 
1685
        except errors.UnknownSmartMethod:
 
1686
            self._ensure_real()
 
1687
            return self._real_repository.break_lock()
 
1688
        if response != ('ok',):
 
1689
            raise errors.UnexpectedSmartServerResponse(response)
1174
1690
 
1175
1691
    def _get_tarball(self, compression):
1176
1692
        """Return a TemporaryFile containing a repository tarball.
1194
1710
            return t
1195
1711
        raise errors.UnexpectedSmartServerResponse(response)
1196
1712
 
 
1713
    @needs_read_lock
1197
1714
    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)
 
1715
        """Create a descendent repository for new development.
 
1716
 
 
1717
        Unlike clone, this does not copy the settings of the repository.
 
1718
        """
 
1719
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1720
        dest_repo.fetch(self, revision_id=revision_id)
1203
1721
        return dest_repo
1204
1722
 
 
1723
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1724
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1725
            # use target default format.
 
1726
            dest_repo = a_bzrdir.create_repository()
 
1727
        else:
 
1728
            # Most control formats need the repository to be specifically
 
1729
            # created, but on some old all-in-one formats it's not needed
 
1730
            try:
 
1731
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1732
            except errors.UninitializableFormat:
 
1733
                dest_repo = a_bzrdir.open_repository()
 
1734
        return dest_repo
 
1735
 
1205
1736
    ### These methods are just thin shims to the VFS object for now.
1206
1737
 
 
1738
    @needs_read_lock
1207
1739
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1740
        revision_id = _mod_revision.ensure_null(revision_id)
 
1741
        if revision_id == _mod_revision.NULL_REVISION:
 
1742
            return InventoryRevisionTree(self,
 
1743
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1744
        else:
 
1745
            return list(self.revision_trees([revision_id]))[0]
1210
1746
 
1211
1747
    def get_serializer_format(self):
1212
 
        self._ensure_real()
1213
 
        return self._real_repository.get_serializer_format()
 
1748
        path = self.bzrdir._path_for_remote_call(self._client)
 
1749
        try:
 
1750
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1751
                path)
 
1752
        except errors.UnknownSmartMethod:
 
1753
            self._ensure_real()
 
1754
            return self._real_repository.get_serializer_format()
 
1755
        if response[0] != 'ok':
 
1756
            raise errors.UnexpectedSmartServerResponse(response)
 
1757
        return response[1]
1214
1758
 
1215
1759
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1760
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1761
                           revision_id=None, lossy=False):
1218
1762
        # FIXME: It ought to be possible to call this without immediately
1219
1763
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1764
        self._ensure_real()
1221
1765
        real_repo = self._real_repository
1222
1766
        builder = real_repo.get_commit_builder(branch, parents,
1223
1767
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1768
                committer=committer, revprops=revprops,
 
1769
                revision_id=revision_id, lossy=lossy)
1225
1770
        return builder
1226
1771
 
1227
1772
    def add_fallback_repository(self, repository):
1235
1780
        # We need to accumulate additional repositories here, to pass them in
1236
1781
        # on various RPC's.
1237
1782
        #
 
1783
        # Make the check before we lock: this raises an exception.
 
1784
        self._check_fallback_repository(repository)
1238
1785
        if self.is_locked():
1239
1786
            # We will call fallback.unlock() when we transition to the unlocked
1240
1787
            # state, so always add a lock here. If a caller passes us a locked
1241
1788
            # repository, they are responsible for unlocking it later.
1242
1789
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1790
        self._fallback_repositories.append(repository)
1245
1791
        # If self._real_repository was parameterised already (e.g. because a
1246
1792
        # _real_branch had its get_stacked_on_url method called), then the
1279
1825
 
1280
1826
    @needs_read_lock
1281
1827
    def get_inventory(self, revision_id):
1282
 
        self._ensure_real()
1283
 
        return self._real_repository.get_inventory(revision_id)
 
1828
        return list(self.iter_inventories([revision_id]))[0]
1284
1829
 
1285
1830
    def iter_inventories(self, revision_ids, ordering=None):
1286
1831
        self._ensure_real()
1288
1833
 
1289
1834
    @needs_read_lock
1290
1835
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1836
        return self.get_revisions([revision_id])[0]
1293
1837
 
1294
1838
    def get_transaction(self):
1295
1839
        self._ensure_real()
1297
1841
 
1298
1842
    @needs_read_lock
1299
1843
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1844
        dest_repo = self._create_sprouting_repo(
 
1845
            a_bzrdir, shared=self.is_shared())
 
1846
        self.copy_content_into(dest_repo, revision_id)
 
1847
        return dest_repo
1302
1848
 
1303
1849
    def make_working_trees(self):
1304
1850
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1851
        path = self.bzrdir._path_for_remote_call(self._client)
 
1852
        try:
 
1853
            response = self._call('Repository.make_working_trees', path)
 
1854
        except errors.UnknownSmartMethod:
 
1855
            self._ensure_real()
 
1856
            return self._real_repository.make_working_trees()
 
1857
        if response[0] not in ('yes', 'no'):
 
1858
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1859
        return response[0] == 'yes'
1307
1860
 
1308
1861
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1862
        """Re-read any data needed to synchronise with disk.
1310
1863
 
1311
1864
        This method is intended to be called after another repository instance
1312
1865
        (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.
 
1866
        repository. On all repositories this will work outside of write groups.
 
1867
        Some repository formats (pack and newer for bzrlib native formats)
 
1868
        support refresh_data inside write groups. If called inside a write
 
1869
        group on a repository that does not support refreshing in a write group
 
1870
        IsInWriteGroupError will be raised.
1315
1871
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1872
        if self._real_repository is not None:
1320
1873
            self._real_repository.refresh_data()
1321
1874
 
1328
1881
        included_keys = result_set.intersection(result_parents)
1329
1882
        start_keys = result_set.difference(included_keys)
1330
1883
        exclude_keys = result_parents.difference(result_set)
1331
 
        result = graph.SearchResult(start_keys, exclude_keys,
 
1884
        result = vf_search.SearchResult(start_keys, exclude_keys,
1332
1885
            len(result_set), result_set)
1333
1886
        return result
1334
1887
 
1335
1888
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1889
    def search_missing_revision_ids(self, other,
 
1890
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1891
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1892
            limit=None):
1337
1893
        """Return the revision ids that other has that this does not.
1338
1894
 
1339
1895
        These are returned in topological order.
1340
1896
 
1341
1897
        revision_id: only return revision ids included by revision_id.
1342
1898
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1899
        if symbol_versioning.deprecated_passed(revision_id):
 
1900
            symbol_versioning.warn(
 
1901
                'search_missing_revision_ids(revision_id=...) was '
 
1902
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1903
                DeprecationWarning, stacklevel=2)
 
1904
            if revision_ids is not None:
 
1905
                raise AssertionError(
 
1906
                    'revision_ids is mutually exclusive with revision_id')
 
1907
            if revision_id is not None:
 
1908
                revision_ids = [revision_id]
 
1909
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1910
        return inter_repo.search_missing_revision_ids(
 
1911
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1912
            if_present_ids=if_present_ids, limit=limit)
1345
1913
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1914
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1915
            fetch_spec=None):
1348
1916
        # No base implementation to use as RemoteRepository is not a subclass
1349
1917
        # of Repository; so this is a copy of Repository.fetch().
1360
1928
            # check that last_revision is in 'from' and then return a
1361
1929
            # no-operation.
1362
1930
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1931
                not _mod_revision.is_null(revision_id)):
1364
1932
                self.get_revision(revision_id)
1365
1933
            return 0, []
1366
1934
        # if there is no specific appropriate InterRepository, this will get
1367
1935
        # the InterRepository base class, which raises an
1368
1936
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1937
        inter = _mod_repository.InterRepository.get(source, self)
 
1938
        if (fetch_spec is not None and
 
1939
            not getattr(inter, "supports_fetch_spec", False)):
 
1940
            raise errors.UnsupportedOperation(
 
1941
                "fetch_spec not supported for %r" % inter)
 
1942
        return inter.fetch(revision_id=revision_id,
1371
1943
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1944
 
1373
1945
    def create_bundle(self, target, base, fileobj, format=None):
1375
1947
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1948
 
1377
1949
    @needs_read_lock
 
1950
    @symbol_versioning.deprecated_method(
 
1951
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1952
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1953
        self._ensure_real()
1380
1954
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1388
1962
        return self._real_repository._get_versioned_file_checker(
1389
1963
            revisions, revision_versions_cache)
1390
1964
 
 
1965
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
1966
        path = self.bzrdir._path_for_remote_call(self._client)
 
1967
        lines = []
 
1968
        identifiers = []
 
1969
        for (file_id, revid, identifier) in desired_files:
 
1970
            lines.append("%s\0%s" % (
 
1971
                osutils.safe_file_id(file_id),
 
1972
                osutils.safe_revision_id(revid)))
 
1973
            identifiers.append(identifier)
 
1974
        (response_tuple, response_handler) = (
 
1975
            self._call_with_body_bytes_expecting_body(
 
1976
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
1977
        if response_tuple != ('ok', ):
 
1978
            response_handler.cancel_read_body()
 
1979
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1980
        byte_stream = response_handler.read_streamed_body()
 
1981
        def decompress_stream(start, byte_stream, unused):
 
1982
            decompressor = zlib.decompressobj()
 
1983
            yield decompressor.decompress(start)
 
1984
            while decompressor.unused_data == "":
 
1985
                try:
 
1986
                    data = byte_stream.next()
 
1987
                except StopIteration:
 
1988
                    break
 
1989
                yield decompressor.decompress(data)
 
1990
            yield decompressor.flush()
 
1991
            unused.append(decompressor.unused_data)
 
1992
        unused = ""
 
1993
        while True:
 
1994
            while not "\n" in unused:
 
1995
                unused += byte_stream.next()
 
1996
            header, rest = unused.split("\n", 1)
 
1997
            args = header.split("\0")
 
1998
            if args[0] == "absent":
 
1999
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2000
                unused = rest
 
2001
                continue
 
2002
            elif args[0] == "ok":
 
2003
                idx = int(args[1])
 
2004
            else:
 
2005
                raise errors.UnexpectedSmartServerResponse(args)
 
2006
            unused_chunks = []
 
2007
            yield (identifiers[idx],
 
2008
                decompress_stream(rest, byte_stream, unused_chunks))
 
2009
            unused = "".join(unused_chunks)
 
2010
 
1391
2011
    def iter_files_bytes(self, desired_files):
1392
2012
        """See Repository.iter_file_bytes.
1393
2013
        """
1394
 
        self._ensure_real()
1395
 
        return self._real_repository.iter_files_bytes(desired_files)
 
2014
        try:
 
2015
            absent = {}
 
2016
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2017
                    desired_files, absent):
 
2018
                yield identifier, bytes_iterator
 
2019
            for fallback in self._fallback_repositories:
 
2020
                if not absent:
 
2021
                    break
 
2022
                desired_files = [(key[0], key[1], identifier) for
 
2023
                    (identifier, key) in absent.iteritems()]
 
2024
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2025
                    del absent[identifier]
 
2026
                    yield identifier, bytes_iterator
 
2027
            if absent:
 
2028
                # There may be more missing items, but raise an exception
 
2029
                # for just one.
 
2030
                missing_identifier = absent.keys()[0]
 
2031
                missing_key = absent[missing_identifier]
 
2032
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2033
                    file_id=missing_key[0])
 
2034
        except errors.UnknownSmartMethod:
 
2035
            self._ensure_real()
 
2036
            for (identifier, bytes_iterator) in (
 
2037
                self._real_repository.iter_files_bytes(desired_files)):
 
2038
                yield identifier, bytes_iterator
 
2039
 
 
2040
    def get_cached_parent_map(self, revision_ids):
 
2041
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2042
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
1396
2043
 
1397
2044
    def get_parent_map(self, revision_ids):
1398
2045
        """See bzrlib.Graph.get_parent_map()."""
1457
2104
        if parents_map is None:
1458
2105
            # Repository is not locked, so there's no cache.
1459
2106
            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)
 
2107
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2108
            (start_set, stop_keys,
 
2109
             key_count) = vf_search.search_result_from_parent_map(
 
2110
                parents_map, self._unstacked_provider.missing_keys)
 
2111
        else:
 
2112
            (start_set, stop_keys,
 
2113
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2114
                parents_map, self._unstacked_provider.missing_keys,
 
2115
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
2116
        recipe = ('manual', start_set, stop_keys, key_count)
1481
2117
        body = self._serialise_search_recipe(recipe)
1482
2118
        path = self.bzrdir._path_for_remote_call(self._client)
1531
2167
 
1532
2168
    @needs_read_lock
1533
2169
    def get_signature_text(self, revision_id):
1534
 
        self._ensure_real()
1535
 
        return self._real_repository.get_signature_text(revision_id)
 
2170
        path = self.bzrdir._path_for_remote_call(self._client)
 
2171
        try:
 
2172
            response_tuple, response_handler = self._call_expecting_body(
 
2173
                'Repository.get_revision_signature_text', path, revision_id)
 
2174
        except errors.UnknownSmartMethod:
 
2175
            self._ensure_real()
 
2176
            return self._real_repository.get_signature_text(revision_id)
 
2177
        except errors.NoSuchRevision, err:
 
2178
            for fallback in self._fallback_repositories:
 
2179
                try:
 
2180
                    return fallback.get_signature_text(revision_id)
 
2181
                except errors.NoSuchRevision:
 
2182
                    pass
 
2183
            raise err
 
2184
        else:
 
2185
            if response_tuple[0] != 'ok':
 
2186
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2187
            return response_handler.read_body_bytes()
1536
2188
 
1537
2189
    @needs_read_lock
1538
2190
    def _get_inventory_xml(self, revision_id):
1539
2191
        self._ensure_real()
1540
2192
        return self._real_repository._get_inventory_xml(revision_id)
1541
2193
 
 
2194
    @needs_write_lock
1542
2195
    def reconcile(self, other=None, thorough=False):
1543
 
        self._ensure_real()
1544
 
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
2196
        from bzrlib.reconcile import RepoReconciler
 
2197
        path = self.bzrdir._path_for_remote_call(self._client)
 
2198
        try:
 
2199
            response, handler = self._call_expecting_body(
 
2200
                'Repository.reconcile', path, self._lock_token)
 
2201
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2202
            self._ensure_real()
 
2203
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2204
        if response != ('ok', ):
 
2205
            raise errors.UnexpectedSmartServerResponse(response)
 
2206
        body = handler.read_body_bytes()
 
2207
        result = RepoReconciler(self)
 
2208
        for line in body.split('\n'):
 
2209
            if not line:
 
2210
                continue
 
2211
            key, val_text = line.split(':')
 
2212
            if key == "garbage_inventories":
 
2213
                result.garbage_inventories = int(val_text)
 
2214
            elif key == "inconsistent_parents":
 
2215
                result.inconsistent_parents = int(val_text)
 
2216
            else:
 
2217
                mutter("unknown reconcile key %r" % key)
 
2218
        return result
1545
2219
 
1546
2220
    def all_revision_ids(self):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.all_revision_ids()
 
2221
        path = self.bzrdir._path_for_remote_call(self._client)
 
2222
        try:
 
2223
            response_tuple, response_handler = self._call_expecting_body(
 
2224
                "Repository.all_revision_ids", path)
 
2225
        except errors.UnknownSmartMethod:
 
2226
            self._ensure_real()
 
2227
            return self._real_repository.all_revision_ids()
 
2228
        if response_tuple != ("ok", ):
 
2229
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2230
        revids = set(response_handler.read_body_bytes().splitlines())
 
2231
        for fallback in self._fallback_repositories:
 
2232
            revids.update(set(fallback.all_revision_ids()))
 
2233
        return list(revids)
1549
2234
 
1550
2235
    @needs_read_lock
1551
2236
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1555
2240
 
1556
2241
    @needs_read_lock
1557
2242
    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)
 
2243
        r = self.get_revision(revision_id)
 
2244
        return list(self.get_deltas_for_revisions([r],
 
2245
            specific_fileids=specific_fileids))[0]
1561
2246
 
1562
2247
    @needs_read_lock
1563
2248
    def revision_trees(self, revision_ids):
1564
 
        self._ensure_real()
1565
 
        return self._real_repository.revision_trees(revision_ids)
 
2249
        inventories = self.iter_inventories(revision_ids)
 
2250
        for inv in inventories:
 
2251
            yield InventoryRevisionTree(self, inv, inv.revision_id)
1566
2252
 
1567
2253
    @needs_read_lock
1568
2254
    def get_revision_reconcile(self, revision_id):
1576
2262
            callback_refs=callback_refs, check_repo=check_repo)
1577
2263
 
1578
2264
    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)
 
2265
        """Make a complete copy of the content in self into destination.
 
2266
 
 
2267
        This is a destructive operation! Do not use it on existing
 
2268
        repositories.
 
2269
        """
 
2270
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2271
        return interrepo.copy_content(revision_id)
1582
2272
 
1583
2273
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2274
        # get a tarball of the remote repository, and copy from that into the
1585
2275
        # destination
1586
 
        from bzrlib import osutils
1587
2276
        import tarfile
1588
2277
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2278
        note(gettext("Copying repository content as tarball..."))
1590
2279
        tar_file = self._get_tarball('bz2')
1591
2280
        if tar_file is None:
1592
2281
            return None
1597
2286
            tmpdir = osutils.mkdtemp()
1598
2287
            try:
1599
2288
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2289
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2290
                tmp_repo = tmp_bzrdir.open_repository()
1602
2291
                tmp_repo.copy_content_into(destination, revision_id)
1603
2292
            finally:
1621
2310
    @needs_write_lock
1622
2311
    def pack(self, hint=None, clean_obsolete_packs=False):
1623
2312
        """Compress the data within the repository.
1624
 
 
1625
 
        This is not currently implemented within the smart server.
1626
2313
        """
1627
 
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2314
        if hint is None:
 
2315
            body = ""
 
2316
        else:
 
2317
            body = "".join([l+"\n" for l in hint])
 
2318
        path = self.bzrdir._path_for_remote_call(self._client)
 
2319
        try:
 
2320
            response, handler = self._call_with_body_bytes_expecting_body(
 
2321
                'Repository.pack', (path, self._lock_token,
 
2322
                    str(clean_obsolete_packs)), body)
 
2323
        except errors.UnknownSmartMethod:
 
2324
            self._ensure_real()
 
2325
            return self._real_repository.pack(hint=hint,
 
2326
                clean_obsolete_packs=clean_obsolete_packs)
 
2327
        handler.cancel_read_body()
 
2328
        if response != ('ok', ):
 
2329
            raise errors.UnexpectedSmartServerResponse(response)
1629
2330
 
1630
2331
    @property
1631
2332
    def revisions(self):
1632
2333
        """Decorate the real repository for now.
1633
2334
 
1634
 
        In the short term this should become a real object to intercept graph
1635
 
        lookups.
1636
 
 
1637
2335
        In the long term a full blown network facility is needed.
1638
2336
        """
1639
2337
        self._ensure_real()
1667
2365
 
1668
2366
    @needs_write_lock
1669
2367
    def sign_revision(self, revision_id, gpg_strategy):
1670
 
        self._ensure_real()
1671
 
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
2368
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2369
        plaintext = testament.as_short_text()
 
2370
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1672
2371
 
1673
2372
    @property
1674
2373
    def texts(self):
1680
2379
        self._ensure_real()
1681
2380
        return self._real_repository.texts
1682
2381
 
 
2382
    def _iter_revisions_rpc(self, revision_ids):
 
2383
        body = "\n".join(revision_ids)
 
2384
        path = self.bzrdir._path_for_remote_call(self._client)
 
2385
        response_tuple, response_handler = (
 
2386
            self._call_with_body_bytes_expecting_body(
 
2387
            "Repository.iter_revisions", (path, ), body))
 
2388
        if response_tuple[0] != "ok":
 
2389
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2390
        serializer_format = response_tuple[1]
 
2391
        serializer = serializer_format_registry.get(serializer_format)
 
2392
        byte_stream = response_handler.read_streamed_body()
 
2393
        decompressor = zlib.decompressobj()
 
2394
        chunks = []
 
2395
        for bytes in byte_stream:
 
2396
            chunks.append(decompressor.decompress(bytes))
 
2397
            if decompressor.unused_data != "":
 
2398
                chunks.append(decompressor.flush())
 
2399
                yield serializer.read_revision_from_string("".join(chunks))
 
2400
                unused = decompressor.unused_data
 
2401
                decompressor = zlib.decompressobj()
 
2402
                chunks = [decompressor.decompress(unused)]
 
2403
        chunks.append(decompressor.flush())
 
2404
        text = "".join(chunks)
 
2405
        if text != "":
 
2406
            yield serializer.read_revision_from_string("".join(chunks))
 
2407
 
1683
2408
    @needs_read_lock
1684
2409
    def get_revisions(self, revision_ids):
1685
 
        self._ensure_real()
1686
 
        return self._real_repository.get_revisions(revision_ids)
 
2410
        if revision_ids is None:
 
2411
            revision_ids = self.all_revision_ids()
 
2412
        else:
 
2413
            for rev_id in revision_ids:
 
2414
                if not rev_id or not isinstance(rev_id, basestring):
 
2415
                    raise errors.InvalidRevisionId(
 
2416
                        revision_id=rev_id, branch=self)
 
2417
        try:
 
2418
            missing = set(revision_ids)
 
2419
            revs = {}
 
2420
            for rev in self._iter_revisions_rpc(revision_ids):
 
2421
                missing.remove(rev.revision_id)
 
2422
                revs[rev.revision_id] = rev
 
2423
        except errors.UnknownSmartMethod:
 
2424
            self._ensure_real()
 
2425
            return self._real_repository.get_revisions(revision_ids)
 
2426
        for fallback in self._fallback_repositories:
 
2427
            if not missing:
 
2428
                break
 
2429
            for revid in list(missing):
 
2430
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2431
                # public method on Repository that could be used to query
 
2432
                # for revision objects *without* failing completely if one
 
2433
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2434
                # but unfortunately that's private and not provided by
 
2435
                # all repository implementations.
 
2436
                try:
 
2437
                    revs[revid] = fallback.get_revision(revid)
 
2438
                except errors.NoSuchRevision:
 
2439
                    pass
 
2440
                else:
 
2441
                    missing.remove(revid)
 
2442
        if missing:
 
2443
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2444
        return [revs[revid] for revid in revision_ids]
1687
2445
 
1688
2446
    def supports_rich_root(self):
1689
2447
        return self._format.rich_root_data
1690
2448
 
 
2449
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2450
    def iter_reverse_revision_history(self, revision_id):
1692
2451
        self._ensure_real()
1693
2452
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2455
    def _serializer(self):
1697
2456
        return self._format._serializer
1698
2457
 
 
2458
    @needs_write_lock
1699
2459
    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)
 
2460
        signature = gpg_strategy.sign(plaintext)
 
2461
        self.add_signature_text(revision_id, signature)
1703
2462
 
1704
2463
    def add_signature_text(self, revision_id, signature):
1705
 
        self._ensure_real()
1706
 
        return self._real_repository.add_signature_text(revision_id, signature)
 
2464
        if self._real_repository:
 
2465
            # If there is a real repository the write group will
 
2466
            # be in the real repository as well, so use that:
 
2467
            self._ensure_real()
 
2468
            return self._real_repository.add_signature_text(
 
2469
                revision_id, signature)
 
2470
        path = self.bzrdir._path_for_remote_call(self._client)
 
2471
        response, handler = self._call_with_body_bytes_expecting_body(
 
2472
            'Repository.add_signature_text', (path, self._lock_token,
 
2473
                revision_id) + tuple(self._write_group_tokens), signature)
 
2474
        handler.cancel_read_body()
 
2475
        self.refresh_data()
 
2476
        if response[0] != 'ok':
 
2477
            raise errors.UnexpectedSmartServerResponse(response)
 
2478
        self._write_group_tokens = response[1:]
1707
2479
 
1708
2480
    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)
 
2481
        path = self.bzrdir._path_for_remote_call(self._client)
 
2482
        try:
 
2483
            response = self._call('Repository.has_signature_for_revision_id',
 
2484
                path, revision_id)
 
2485
        except errors.UnknownSmartMethod:
 
2486
            self._ensure_real()
 
2487
            return self._real_repository.has_signature_for_revision_id(
 
2488
                revision_id)
 
2489
        if response[0] not in ('yes', 'no'):
 
2490
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2491
        if response[0] == 'yes':
 
2492
            return True
 
2493
        for fallback in self._fallback_repositories:
 
2494
            if fallback.has_signature_for_revision_id(revision_id):
 
2495
                return True
 
2496
        return False
 
2497
 
 
2498
    @needs_read_lock
 
2499
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2500
        if not self.has_signature_for_revision_id(revision_id):
 
2501
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2502
        signature = self.get_signature_text(revision_id)
 
2503
 
 
2504
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2505
        plaintext = testament.as_short_text()
 
2506
 
 
2507
        return gpg_strategy.verify(signature, plaintext)
1711
2508
 
1712
2509
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2510
        self._ensure_real()
1714
2511
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2512
            _files_pb=_files_pb)
1716
2513
 
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
2514
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2515
        self._ensure_real()
1724
2516
        return self._real_repository._find_inconsistent_revision_parents(
1732
2524
        providers = [self._unstacked_provider]
1733
2525
        if other is not None:
1734
2526
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2527
        return graph.StackedParentsProvider(_LazyListJoin(
 
2528
            providers, self._fallback_repositories))
1738
2529
 
1739
2530
    def _serialise_search_recipe(self, recipe):
1740
2531
        """Serialise a graph search recipe.
1748
2539
        return '\n'.join((start_keys, stop_keys, count))
1749
2540
 
1750
2541
    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)]
 
2542
        parts = search_result.get_network_struct()
1757
2543
        return '\n'.join(parts)
1758
2544
 
1759
2545
    def autopack(self):
1769
2555
            raise errors.UnexpectedSmartServerResponse(response)
1770
2556
 
1771
2557
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2558
class RemoteStreamSink(vf_repository.StreamSink):
1773
2559
 
1774
2560
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2561
        self.target_repo._ensure_real()
1876
2662
        self._last_substream and self._last_stream so that the stream can be
1877
2663
        resumed by _resume_stream_with_vfs.
1878
2664
        """
1879
 
                    
 
2665
 
1880
2666
        stream_iter = iter(stream)
1881
2667
        for substream_kind, substream in stream_iter:
1882
2668
            if substream_kind == 'inventory-deltas':
1885
2671
                return
1886
2672
            else:
1887
2673
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2674
 
 
2675
 
 
2676
class RemoteStreamSource(vf_repository.StreamSource):
1891
2677
    """Stream data from a remote server."""
1892
2678
 
1893
2679
    def get_stream(self, search):
1914
2700
 
1915
2701
    def _real_stream(self, repo, search):
1916
2702
        """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 
 
2703
 
 
2704
        This never called RemoteStreamSource.get_stream, and is a helper
 
2705
        for RemoteStreamSource._get_stream to allow getting a stream
1920
2706
        reliably whether fallback back because of old servers or trying
1921
2707
        to stream from a non-RemoteRepository (which the stacked support
1922
2708
        code will do).
1953
2739
        candidate_verbs = [
1954
2740
            ('Repository.get_stream_1.19', (1, 19)),
1955
2741
            ('Repository.get_stream', (1, 13))]
 
2742
 
1956
2743
        found_verb = False
1957
2744
        for verb, version in candidate_verbs:
1958
2745
            if medium._is_remote_before(version):
1962
2749
                    verb, args, search_bytes)
1963
2750
            except errors.UnknownSmartMethod:
1964
2751
                medium._remember_remote_is_before(version)
 
2752
            except errors.UnknownErrorFromSmartServer, e:
 
2753
                if isinstance(search, vf_search.EverythingResult):
 
2754
                    error_verb = e.error_from_smart_server.error_verb
 
2755
                    if error_verb == 'BadSearch':
 
2756
                        # Pre-2.4 servers don't support this sort of search.
 
2757
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2758
                        # good idea in general?  It might provide a little bit
 
2759
                        # of protection against client-side bugs.
 
2760
                        medium._remember_remote_is_before((2, 4))
 
2761
                        break
 
2762
                raise
1965
2763
            else:
1966
2764
                response_tuple, response_handler = response
1967
2765
                found_verb = True
1971
2769
        if response_tuple[0] != 'ok':
1972
2770
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2771
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2772
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2773
            self._record_counter)
1975
2774
        if src_format.network_name() != repo._format.network_name():
1976
2775
            raise AssertionError(
1977
2776
                "Mismatched RemoteRepository and stream src %r, %r" % (
2049
2848
 
2050
2849
    def _ensure_real(self):
2051
2850
        if self._custom_format is None:
2052
 
            self._custom_format = branch.network_format_registry.get(
2053
 
                self._network_name)
 
2851
            try:
 
2852
                self._custom_format = branch.network_format_registry.get(
 
2853
                    self._network_name)
 
2854
            except KeyError:
 
2855
                raise errors.UnknownFormatError(kind='branch',
 
2856
                    format=self._network_name)
2054
2857
 
2055
2858
    def get_format_description(self):
2056
2859
        self._ensure_real()
2063
2866
        return a_bzrdir.open_branch(name=name, 
2064
2867
            ignore_fallbacks=ignore_fallbacks)
2065
2868
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2869
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2870
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2871
        # method is not available on the server.
2069
2872
        # self._custom_format is always set - the start of initialize ensures
2071
2874
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2875
            a_bzrdir._ensure_real()
2073
2876
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2877
                name, append_revisions_only=append_revisions_only)
2075
2878
        else:
2076
2879
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2880
            result = self._custom_format.initialize(a_bzrdir, name,
 
2881
                append_revisions_only=append_revisions_only)
2078
2882
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2883
            not isinstance(result, RemoteBranch)):
2080
2884
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2885
                                  name=name)
2082
2886
        return result
2083
2887
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2888
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2889
                   append_revisions_only=None):
2085
2890
        # 1) get the network name to use.
2086
2891
        if self._custom_format:
2087
2892
            network_name = self._custom_format.network_name()
2088
2893
        else:
2089
2894
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2895
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2896
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2897
            self._custom_format = reference_format
2093
2898
            network_name = reference_format.network_name()
2094
2899
        # Being asked to create on a non RemoteBzrDir:
2095
2900
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2901
            return self._vfs_initialize(a_bzrdir, name=name,
 
2902
                append_revisions_only=append_revisions_only)
2097
2903
        medium = a_bzrdir._client._medium
2098
2904
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2905
            return self._vfs_initialize(a_bzrdir, name=name,
 
2906
                append_revisions_only=append_revisions_only)
2100
2907
        # Creating on a remote bzr dir.
2101
2908
        # 2) try direct creation via RPC
2102
2909
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2916
        except errors.UnknownSmartMethod:
2110
2917
            # Fallback - use vfs methods
2111
2918
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2919
            return self._vfs_initialize(a_bzrdir, name=name,
 
2920
                    append_revisions_only=append_revisions_only)
2113
2921
        if response[0] != 'ok':
2114
2922
            raise errors.UnexpectedSmartServerResponse(response)
2115
2923
        # Turn the response into a RemoteRepository object.
2116
2924
        format = RemoteBranchFormat(network_name=response[1])
2117
2925
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2926
        repo_path = response[2]
 
2927
        if repository is not None:
 
2928
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2929
            url_diff = urlutils.relative_url(repository.user_url,
 
2930
                    remote_repo_url)
 
2931
            if url_diff != '.':
 
2932
                raise AssertionError(
 
2933
                    'repository.user_url %r does not match URL from server '
 
2934
                    'response (%r + %r)'
 
2935
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2936
            remote_repo = repository
2120
2937
        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)
 
2938
            if repo_path == '':
 
2939
                repo_bzrdir = a_bzrdir
 
2940
            else:
 
2941
                repo_bzrdir = RemoteBzrDir(
 
2942
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2943
                    a_bzrdir._client)
 
2944
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2945
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2946
            format=format, setup_stacking=False, name=name)
 
2947
        if append_revisions_only:
 
2948
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2949
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2950
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2951
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2970
        self._ensure_real()
2149
2971
        return self._custom_format.supports_set_append_revisions_only()
2150
2972
 
 
2973
    def _use_default_local_heads_to_fetch(self):
 
2974
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2975
        # implementation is not overridden vs the base class, we can use the
 
2976
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2977
        # usually cheaper in terms of net round trips, as the last-revision and
 
2978
        # tags info fetched is cached and would be fetched anyway.
 
2979
        self._ensure_real()
 
2980
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2981
            branch_class = self._custom_format._branch_class()
 
2982
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2983
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2984
                return True
 
2985
        return False
 
2986
 
 
2987
 
 
2988
class RemoteBranchStore(config.IniFileStore):
 
2989
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2990
 
 
2991
    Note that this is specific to bzr-based formats.
 
2992
    """
 
2993
 
 
2994
    def __init__(self, branch):
 
2995
        super(RemoteBranchStore, self).__init__()
 
2996
        self.branch = branch
 
2997
        self.id = "branch"
 
2998
        self._real_store = None
 
2999
 
 
3000
    def lock_write(self, token=None):
 
3001
        return self.branch.lock_write(token)
 
3002
 
 
3003
    def unlock(self):
 
3004
        return self.branch.unlock()
 
3005
 
 
3006
    @needs_write_lock
 
3007
    def save(self):
 
3008
        # We need to be able to override the undecorated implementation
 
3009
        self.save_without_locking()
 
3010
 
 
3011
    def save_without_locking(self):
 
3012
        super(RemoteBranchStore, self).save()
 
3013
 
 
3014
    def external_url(self):
 
3015
        return self.branch.user_url
 
3016
 
 
3017
    def _load_content(self):
 
3018
        path = self.branch._remote_path()
 
3019
        try:
 
3020
            response, handler = self.branch._call_expecting_body(
 
3021
                'Branch.get_config_file', path)
 
3022
        except errors.UnknownSmartMethod:
 
3023
            self._ensure_real()
 
3024
            return self._real_store._load_content()
 
3025
        if len(response) and response[0] != 'ok':
 
3026
            raise errors.UnexpectedSmartServerResponse(response)
 
3027
        return handler.read_body_bytes()
 
3028
 
 
3029
    def _save_content(self, content):
 
3030
        path = self.branch._remote_path()
 
3031
        try:
 
3032
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3033
                'Branch.put_config_file', (path,
 
3034
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3035
                content)
 
3036
        except errors.UnknownSmartMethod:
 
3037
            self._ensure_real()
 
3038
            return self._real_store._save_content(content)
 
3039
        handler.cancel_read_body()
 
3040
        if response != ('ok', ):
 
3041
            raise errors.UnexpectedSmartServerResponse(response)
 
3042
 
 
3043
    def _ensure_real(self):
 
3044
        self.branch._ensure_real()
 
3045
        if self._real_store is None:
 
3046
            self._real_store = config.BranchStore(self.branch)
 
3047
 
2151
3048
 
2152
3049
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
3050
    """Branch stored on a server accessed by HPSS RPC.
2156
3053
    """
2157
3054
 
2158
3055
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
3056
        _client=None, format=None, setup_stacking=True, name=None,
 
3057
        possible_transports=None):
2160
3058
        """Create a RemoteBranch instance.
2161
3059
 
2162
3060
        :param real_branch: An optional local implementation of the branch
2227
3125
            hook(self)
2228
3126
        self._is_stacked = False
2229
3127
        if setup_stacking:
2230
 
            self._setup_stacking()
 
3128
            self._setup_stacking(possible_transports)
2231
3129
 
2232
 
    def _setup_stacking(self):
 
3130
    def _setup_stacking(self, possible_transports):
2233
3131
        # configure stacking into the remote repository, by reading it from
2234
3132
        # the vfs branch.
2235
3133
        try:
2238
3136
            errors.UnstackableRepositoryFormat), e:
2239
3137
            return
2240
3138
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
 
3139
        if possible_transports is None:
 
3140
            possible_transports = []
 
3141
        else:
 
3142
            possible_transports = list(possible_transports)
 
3143
        possible_transports.append(self.bzrdir.root_transport)
 
3144
        self._activate_fallback_location(fallback_url,
 
3145
            possible_transports=possible_transports)
2242
3146
 
2243
3147
    def _get_config(self):
2244
3148
        return RemoteBranchConfig(self)
2245
3149
 
 
3150
    def _get_config_store(self):
 
3151
        return RemoteBranchStore(self)
 
3152
 
2246
3153
    def _get_real_transport(self):
2247
3154
        # if we try vfs access, return the real branch's vfs transport
2248
3155
        self._ensure_real()
2311
3218
                self.bzrdir, self._client)
2312
3219
        return self._control_files
2313
3220
 
2314
 
    def _get_checkout_format(self):
2315
 
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
2317
 
 
2318
3221
    def get_physical_lock_status(self):
2319
3222
        """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()
 
3223
        try:
 
3224
            response = self._client.call('Branch.get_physical_lock_status',
 
3225
                self._remote_path())
 
3226
        except errors.UnknownSmartMethod:
 
3227
            self._ensure_real()
 
3228
            return self._real_branch.get_physical_lock_status()
 
3229
        if response[0] not in ('yes', 'no'):
 
3230
            raise errors.UnexpectedSmartServerResponse(response)
 
3231
        return (response[0] == 'yes')
2323
3232
 
2324
3233
    def get_stacked_on_url(self):
2325
3234
        """Get the URL this branch is stacked against.
2352
3261
            self._is_stacked = False
2353
3262
        else:
2354
3263
            self._is_stacked = True
2355
 
        
 
3264
 
2356
3265
    def _vfs_get_tags_bytes(self):
2357
3266
        self._ensure_real()
2358
3267
        return self._real_branch._get_tags_bytes()
2359
3268
 
 
3269
    @needs_read_lock
2360
3270
    def _get_tags_bytes(self):
 
3271
        if self._tags_bytes is None:
 
3272
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3273
        return self._tags_bytes
 
3274
 
 
3275
    def _get_tags_bytes_via_hpss(self):
2361
3276
        medium = self._client._medium
2362
3277
        if medium._is_remote_before((1, 13)):
2363
3278
            return self._vfs_get_tags_bytes()
2373
3288
        return self._real_branch._set_tags_bytes(bytes)
2374
3289
 
2375
3290
    def _set_tags_bytes(self, bytes):
 
3291
        if self.is_locked():
 
3292
            self._tags_bytes = bytes
2376
3293
        medium = self._client._medium
2377
3294
        if medium._is_remote_before((1, 18)):
2378
3295
            self._vfs_set_tags_bytes(bytes)
2387
3304
            self._vfs_set_tags_bytes(bytes)
2388
3305
 
2389
3306
    def lock_read(self):
 
3307
        """Lock the branch for read operations.
 
3308
 
 
3309
        :return: A bzrlib.lock.LogicalLockResult.
 
3310
        """
2390
3311
        self.repository.lock_read()
2391
3312
        if not self._lock_mode:
2392
3313
            self._note_lock('r')
2396
3317
                self._real_branch.lock_read()
2397
3318
        else:
2398
3319
            self._lock_count += 1
 
3320
        return lock.LogicalLockResult(self.unlock)
2399
3321
 
2400
3322
    def _remote_lock_write(self, token):
2401
3323
        if token is None:
2402
3324
            branch_token = repo_token = ''
2403
3325
        else:
2404
3326
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
3327
            repo_token = self.repository.lock_write().repository_token
2406
3328
            self.repository.unlock()
2407
3329
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
3330
        try:
 
3331
            response = self._call(
 
3332
                'Branch.lock_write', self._remote_path(), branch_token,
 
3333
                repo_token or '', **err_context)
 
3334
        except errors.LockContention, e:
 
3335
            # The LockContention from the server doesn't have any
 
3336
            # information about the lock_url. We re-raise LockContention
 
3337
            # with valid lock_url.
 
3338
            raise errors.LockContention('(remote lock)',
 
3339
                self.repository.base.split('.bzr/')[0])
2411
3340
        if response[0] != 'ok':
2412
3341
            raise errors.UnexpectedSmartServerResponse(response)
2413
3342
        ok, branch_token, repo_token = response
2434
3363
            self._lock_mode = 'w'
2435
3364
            self._lock_count = 1
2436
3365
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3366
            raise errors.ReadOnlyError(self)
2438
3367
        else:
2439
3368
            if token is not None:
2440
3369
                # A token was given to lock_write, and we're relocking, so
2445
3374
            self._lock_count += 1
2446
3375
            # Re-lock the repository too.
2447
3376
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3377
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3378
 
2450
3379
    def _unlock(self, branch_token, repo_token):
2451
3380
        err_context = {'token': str((branch_token, repo_token))}
2489
3418
            self.repository.unlock()
2490
3419
 
2491
3420
    def break_lock(self):
2492
 
        self._ensure_real()
2493
 
        return self._real_branch.break_lock()
 
3421
        try:
 
3422
            response = self._call(
 
3423
                'Branch.break_lock', self._remote_path())
 
3424
        except errors.UnknownSmartMethod:
 
3425
            self._ensure_real()
 
3426
            return self._real_branch.break_lock()
 
3427
        if response != ('ok',):
 
3428
            raise errors.UnexpectedSmartServerResponse(response)
2494
3429
 
2495
3430
    def leave_lock_in_place(self):
2496
3431
        if not self._lock_token:
2520
3455
            missing_parent = parent_map[missing_parent]
2521
3456
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3457
 
2523
 
    def _last_revision_info(self):
 
3458
    def _read_last_revision_info(self):
2524
3459
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3460
        if response[0] != 'ok':
2526
3461
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3524
            raise errors.UnexpectedSmartServerResponse(response)
2590
3525
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3526
 
 
3527
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3528
    @needs_write_lock
2593
3529
    def set_revision_history(self, rev_history):
 
3530
        """See Branch.set_revision_history."""
 
3531
        self._set_revision_history(rev_history)
 
3532
 
 
3533
    @needs_write_lock
 
3534
    def _set_revision_history(self, rev_history):
2594
3535
        # Send just the tip revision of the history; the server will generate
2595
3536
        # the full history from that.  If the revision doesn't exist in this
2596
3537
        # branch, NoSuchRevision will be raised.
2654
3595
            _override_hook_target=self, **kwargs)
2655
3596
 
2656
3597
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3598
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3599
        self._ensure_real()
2659
3600
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3601
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3602
            _override_hook_source_branch=self)
2662
3603
 
2663
3604
    def is_locked(self):
2664
3605
        return self._lock_count >= 1
2665
3606
 
2666
3607
    @needs_read_lock
 
3608
    def revision_id_to_dotted_revno(self, revision_id):
 
3609
        """Given a revision id, return its dotted revno.
 
3610
 
 
3611
        :return: a tuple like (1,) or (400,1,3).
 
3612
        """
 
3613
        try:
 
3614
            response = self._call('Branch.revision_id_to_revno',
 
3615
                self._remote_path(), revision_id)
 
3616
        except errors.UnknownSmartMethod:
 
3617
            self._ensure_real()
 
3618
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3619
        if response[0] == 'ok':
 
3620
            return tuple([int(x) for x in response[1:]])
 
3621
        else:
 
3622
            raise errors.UnexpectedSmartServerResponse(response)
 
3623
 
 
3624
    @needs_read_lock
2667
3625
    def revision_id_to_revno(self, revision_id):
2668
 
        self._ensure_real()
2669
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3626
        """Given a revision id on the branch mainline, return its revno.
 
3627
 
 
3628
        :return: an integer
 
3629
        """
 
3630
        try:
 
3631
            response = self._call('Branch.revision_id_to_revno',
 
3632
                self._remote_path(), revision_id)
 
3633
        except errors.UnknownSmartMethod:
 
3634
            self._ensure_real()
 
3635
            return self._real_branch.revision_id_to_revno(revision_id)
 
3636
        if response[0] == 'ok':
 
3637
            if len(response) == 2:
 
3638
                return int(response[1])
 
3639
            raise NoSuchRevision(self, revision_id)
 
3640
        else:
 
3641
            raise errors.UnexpectedSmartServerResponse(response)
2670
3642
 
2671
3643
    @needs_write_lock
2672
3644
    def set_last_revision_info(self, revno, revision_id):
2673
3645
        # XXX: These should be returned by the set_last_revision_info verb
2674
3646
        old_revno, old_revid = self.last_revision_info()
2675
3647
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3648
        if not revision_id or not isinstance(revision_id, basestring):
 
3649
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3650
        try:
2678
3651
            response = self._call('Branch.set_last_revision_info',
2679
3652
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3681
            except errors.UnknownSmartMethod:
2709
3682
                medium._remember_remote_is_before((1, 6))
2710
3683
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3684
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3685
            last_rev=last_rev,other_branch=other_branch))
2713
3686
 
2714
3687
    def set_push_location(self, location):
2715
3688
        self._ensure_real()
2716
3689
        return self._real_branch.set_push_location(location)
2717
3690
 
 
3691
    def heads_to_fetch(self):
 
3692
        if self._format._use_default_local_heads_to_fetch():
 
3693
            # We recognise this format, and its heads-to-fetch implementation
 
3694
            # is the default one (tip + tags).  In this case it's cheaper to
 
3695
            # just use the default implementation rather than a special RPC as
 
3696
            # the tip and tags data is cached.
 
3697
            return branch.Branch.heads_to_fetch(self)
 
3698
        medium = self._client._medium
 
3699
        if medium._is_remote_before((2, 4)):
 
3700
            return self._vfs_heads_to_fetch()
 
3701
        try:
 
3702
            return self._rpc_heads_to_fetch()
 
3703
        except errors.UnknownSmartMethod:
 
3704
            medium._remember_remote_is_before((2, 4))
 
3705
            return self._vfs_heads_to_fetch()
 
3706
 
 
3707
    def _rpc_heads_to_fetch(self):
 
3708
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3709
        if len(response) != 2:
 
3710
            raise errors.UnexpectedSmartServerResponse(response)
 
3711
        must_fetch, if_present_fetch = response
 
3712
        return set(must_fetch), set(if_present_fetch)
 
3713
 
 
3714
    def _vfs_heads_to_fetch(self):
 
3715
        self._ensure_real()
 
3716
        return self._real_branch.heads_to_fetch()
 
3717
 
2718
3718
 
2719
3719
class RemoteConfig(object):
2720
3720
    """A Config that reads and writes from smart verbs.
2734
3734
        """
2735
3735
        try:
2736
3736
            configobj = self._get_configobj()
 
3737
            section_obj = None
2737
3738
            if section is None:
2738
3739
                section_obj = configobj
2739
3740
            else:
2740
3741
                try:
2741
3742
                    section_obj = configobj[section]
2742
3743
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3744
                    pass
 
3745
            if section_obj is None:
 
3746
                value = default
 
3747
            else:
 
3748
                value = section_obj.get(name, default)
2745
3749
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3750
            value = self._vfs_get_option(name, section, default)
 
3751
        for hook in config.OldConfigHooks['get']:
 
3752
            hook(self, name, value)
 
3753
        return value
2747
3754
 
2748
3755
    def _response_to_configobj(self, response):
2749
3756
        if len(response[0]) and response[0][0] != 'ok':
2750
3757
            raise errors.UnexpectedSmartServerResponse(response)
2751
3758
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3759
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3760
        for hook in config.OldConfigHooks['load']:
 
3761
            hook(self)
 
3762
        return conf
2753
3763
 
2754
3764
 
2755
3765
class RemoteBranchConfig(RemoteConfig):
2774
3784
        medium = self._branch._client._medium
2775
3785
        if medium._is_remote_before((1, 14)):
2776
3786
            return self._vfs_set_option(value, name, section)
 
3787
        if isinstance(value, dict):
 
3788
            if medium._is_remote_before((2, 2)):
 
3789
                return self._vfs_set_option(value, name, section)
 
3790
            return self._set_config_option_dict(value, name, section)
 
3791
        else:
 
3792
            return self._set_config_option(value, name, section)
 
3793
 
 
3794
    def _set_config_option(self, value, name, section):
2777
3795
        try:
2778
3796
            path = self._branch._remote_path()
2779
3797
            response = self._branch._client.call('Branch.set_config_option',
2780
3798
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3799
                value.encode('utf8'), name, section or '')
2782
3800
        except errors.UnknownSmartMethod:
 
3801
            medium = self._branch._client._medium
2783
3802
            medium._remember_remote_is_before((1, 14))
2784
3803
            return self._vfs_set_option(value, name, section)
2785
3804
        if response != ():
2786
3805
            raise errors.UnexpectedSmartServerResponse(response)
2787
3806
 
 
3807
    def _serialize_option_dict(self, option_dict):
 
3808
        utf8_dict = {}
 
3809
        for key, value in option_dict.items():
 
3810
            if isinstance(key, unicode):
 
3811
                key = key.encode('utf8')
 
3812
            if isinstance(value, unicode):
 
3813
                value = value.encode('utf8')
 
3814
            utf8_dict[key] = value
 
3815
        return bencode.bencode(utf8_dict)
 
3816
 
 
3817
    def _set_config_option_dict(self, value, name, section):
 
3818
        try:
 
3819
            path = self._branch._remote_path()
 
3820
            serialised_dict = self._serialize_option_dict(value)
 
3821
            response = self._branch._client.call(
 
3822
                'Branch.set_config_option_dict',
 
3823
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3824
                serialised_dict, name, section or '')
 
3825
        except errors.UnknownSmartMethod:
 
3826
            medium = self._branch._client._medium
 
3827
            medium._remember_remote_is_before((2, 2))
 
3828
            return self._vfs_set_option(value, name, section)
 
3829
        if response != ():
 
3830
            raise errors.UnexpectedSmartServerResponse(response)
 
3831
 
2788
3832
    def _real_object(self):
2789
3833
        self._branch._ensure_real()
2790
3834
        return self._branch._real_branch
2829
3873
        return self._bzrdir._real_bzrdir
2830
3874
 
2831
3875
 
2832
 
 
2833
3876
def _extract_tar(tar, to_dir):
2834
3877
    """Extract all the contents of a tarfile object.
2835
3878
 
2839
3882
        tar.extract(tarinfo, to_dir)
2840
3883
 
2841
3884
 
 
3885
error_translators = registry.Registry()
 
3886
no_context_error_translators = registry.Registry()
 
3887
 
 
3888
 
2842
3889
def _translate_error(err, **context):
2843
3890
    """Translate an ErrorFromSmartServer into a more useful error.
2844
3891
 
2873
3920
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3921
                raise err
2875
3922
 
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'):
 
3923
    try:
 
3924
        translator = error_translators.get(err.error_verb)
 
3925
    except KeyError:
 
3926
        pass
 
3927
    else:
 
3928
        raise translator(err, find, get_path)
 
3929
    try:
 
3930
        translator = no_context_error_translators.get(err.error_verb)
 
3931
    except KeyError:
 
3932
        raise errors.UnknownErrorFromSmartServer(err)
 
3933
    else:
 
3934
        raise translator(err)
 
3935
 
 
3936
 
 
3937
error_translators.register('NoSuchRevision',
 
3938
    lambda err, find, get_path: NoSuchRevision(
 
3939
        find('branch'), err.error_args[0]))
 
3940
error_translators.register('nosuchrevision',
 
3941
    lambda err, find, get_path: NoSuchRevision(
 
3942
        find('repository'), err.error_args[0]))
 
3943
 
 
3944
def _translate_nobranch_error(err, find, get_path):
 
3945
    if len(err.error_args) >= 1:
 
3946
        extra = err.error_args[0]
 
3947
    else:
 
3948
        extra = None
 
3949
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3950
        detail=extra)
 
3951
 
 
3952
error_translators.register('nobranch', _translate_nobranch_error)
 
3953
error_translators.register('norepository',
 
3954
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3955
        find('bzrdir')))
 
3956
error_translators.register('UnlockableTransport',
 
3957
    lambda err, find, get_path: errors.UnlockableTransport(
 
3958
        find('bzrdir').root_transport))
 
3959
error_translators.register('TokenMismatch',
 
3960
    lambda err, find, get_path: errors.TokenMismatch(
 
3961
        find('token'), '(remote token)'))
 
3962
error_translators.register('Diverged',
 
3963
    lambda err, find, get_path: errors.DivergedBranches(
 
3964
        find('branch'), find('other_branch')))
 
3965
error_translators.register('NotStacked',
 
3966
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3967
 
 
3968
def _translate_PermissionDenied(err, find, get_path):
 
3969
    path = get_path()
 
3970
    if len(err.error_args) >= 2:
 
3971
        extra = err.error_args[1]
 
3972
    else:
 
3973
        extra = None
 
3974
    return errors.PermissionDenied(path, extra=extra)
 
3975
 
 
3976
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3977
error_translators.register('ReadError',
 
3978
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3979
error_translators.register('NoSuchFile',
 
3980
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3981
error_translators.register('TokenLockingNotSupported',
 
3982
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
3983
        find('repository')))
 
3984
error_translators.register('UnsuspendableWriteGroup',
 
3985
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3986
        repository=find('repository')))
 
3987
error_translators.register('UnresumableWriteGroup',
 
3988
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3989
        repository=find('repository'), write_groups=err.error_args[0],
 
3990
        reason=err.error_args[1]))
 
3991
no_context_error_translators.register('IncompatibleRepositories',
 
3992
    lambda err: errors.IncompatibleRepositories(
 
3993
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3994
no_context_error_translators.register('LockContention',
 
3995
    lambda err: errors.LockContention('(remote lock)'))
 
3996
no_context_error_translators.register('LockFailed',
 
3997
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3998
no_context_error_translators.register('TipChangeRejected',
 
3999
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4000
no_context_error_translators.register('UnstackableBranchFormat',
 
4001
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4002
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4003
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4004
no_context_error_translators.register('FileExists',
 
4005
    lambda err: errors.FileExists(err.error_args[0]))
 
4006
no_context_error_translators.register('DirectoryNotEmpty',
 
4007
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4008
 
 
4009
def _translate_short_readv_error(err):
 
4010
    args = err.error_args
 
4011
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4012
        int(args[3]))
 
4013
 
 
4014
no_context_error_translators.register('ShortReadvError',
 
4015
    _translate_short_readv_error)
 
4016
 
 
4017
def _translate_unicode_error(err):
2932
4018
        encoding = str(err.error_args[0]) # encoding must always be a string
2933
4019
        val = err.error_args[1]
2934
4020
        start = int(err.error_args[2])
2942
4028
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2943
4029
        elif err.error_verb == 'UnicodeEncodeError':
2944
4030
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
 
    elif err.error_verb == 'ReadOnlyError':
2946
 
        raise errors.TransportNotPossible('readonly transport')
2947
 
    raise errors.UnknownErrorFromSmartServer(err)
 
4031
 
 
4032
no_context_error_translators.register('UnicodeEncodeError',
 
4033
    _translate_unicode_error)
 
4034
no_context_error_translators.register('UnicodeDecodeError',
 
4035
    _translate_unicode_error)
 
4036
no_context_error_translators.register('ReadOnlyError',
 
4037
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4038
no_context_error_translators.register('MemoryError',
 
4039
    lambda err: errors.BzrError("remote server out of memory\n"
 
4040
        "Retry non-remotely, or contact the server admin for details."))
 
4041
no_context_error_translators.register('RevisionNotPresent',
 
4042
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4043
 
 
4044
no_context_error_translators.register('BzrCheckError',
 
4045
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4046